currencyapi-node 1.0.0 → 1.1.1

package/.github/workflows/tests.yml

@@ -0,0 +1,29 @@
+name: Running Code Coverage
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 15.x, 16.x, 18.x]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - name: Set up Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Run tests
+      run: npm run test
+
+    - name: Upload coverage to Coveralls
+      uses: coverallsapp/github-action@v2

package/Dockerfile

@@ -0,0 +1,11 @@
+FROM node:18-slim
+
+USER node
+ARG APP_DIR=/home/node/app
+
+RUN mkdir -p $APP_DIR
+WORKDIR $APP_DIR
+
+COPY --chown=node:node package*.json $APP_DIR/
+
+RUN npm i

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Oliver Girling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Makefile

@@ -0,0 +1,22 @@
+.DEFAULT_GOAL := help
+.PHONY: help
+LOCAL_DOCKER_IMAGE=houseofapis/currencyapi-node
+CONTAINER_NAME=currencyapi-node
+WORKING_DIR=/application
+PORT=7003
+DOCKER_COMMAND=docker run --rm -v ${PWD}:${WORKING_DIR} -w ${WORKING_DIR} --name ${CONTAINER_NAME} -p ${PORT}:${PORT} -it ${LOCAL_DOCKER_IMAGE}
+
+build: ## Build docker image
+	docker build -t ${LOCAL_DOCKER_IMAGE} . --no-cache
+
+test: ## Run the tests
+	${DOCKER_COMMAND} npm test
+
+install: ## Npm install
+	${DOCKER_COMMAND} npm i
+
+run: ## Run test file
+	${DOCKER_COMMAND} npm publish
+
+help:
+	@grep -h -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'

package/README.md

@@ -1,5 +1,9 @@
 # CurrencyApi NodeJs wrapper 
 
+
+[![npm version](https://badge.fury.io/js/currencyapi-node.svg)](https://www.npmjs.com/package/currencyapi-node) [![Coverage Status](https://coveralls.io/repos/github/houseofapis/currencyapi-node/badge.svg?branch=master)](https://coveralls.io/github/houseofapis/currencyapi-node?branch=master) 
+
+
 <a href="https://currencyapi.net" title="CurrencyApi">CurrencyApi.net</a> provides live currency rates via a REST API. A live currency feed for over 152 currencies, including physical (USD, GBP, EUR + more) and cryptos (Bitcoin, Litecoin, Ethereum + more). A JSON and XML currency api updated every 60 seconds. 
 
 Features:
@@ -20,8 +24,13 @@ NodeJs wrapper for <a href="https://currencyapi.net" title="CurrencyApi">Currenc
 #### Prerequisites
 
 - Minimum NodeJs v8 (npm v5 and above)
+- Working on NodeJs v18
 - Free or Paid account with CurrencyApi.net
 
+#### Test Coverage
+
+- 100% coverage
+
 ## Installation
 
 #### Using npm:

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "currencyapi-node",
   "description": "Npm package for the CurrencyApi.net JSON & XML live currency feed",
-  "keywords": ["currency","feed","api","live-rates", "json currency", "crypto"],
+  "keywords": [
+    "currency",
+    "feed",
+    "api",
+    "live-rates",
+    "json currency",
+    "crypto"
+  ],
   "homepage": "https://currencyapi.net",
   "authors": [
     {
@@ -11,8 +18,14 @@
       "role": "Developer"
     }
   ],
-  "version": "1.0.0",
+  "version": "1.1.1",
+  "scripts": {
+    "test": "jest --coverage --collectCoverageFrom='./src/**'"
+  },
   "dependencies": {
-    "node-fetch": "^2.6.0"
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
   }
 }

package/run.js

@@ -0,0 +1,6 @@
+const CurrencyApi = require('./src/CurrencyApi')
+
+const currency = new CurrencyApi('API_KEY');
+currency.rates().output('JSON').get()
+    .then(console.log)
+

package/src/classes/Endpoint.js

@@ -1,4 +1,4 @@
-const client = require("node-fetch");
+const fetch = require("node-fetch");
 
 /**
  * Default output format
@@ -21,18 +21,6 @@ const API_VERSION = 'v1';
  */
 const DEFAULT_BASE = 'USD';
 
-/**
- * Version of the application
- * @type {string}
- */
-const APPLICATION_VERSION = '1.0.0'
-
-/**
- * Application name sent as user-agent
- * @type {string}
- */
-const APPLICATION = 'CurrencyApi_npm_' + APPLICATION_VERSION
-
 /**
  * Build up the URL based on the endpoint and params
  *
@@ -41,7 +29,7 @@ const APPLICATION = 'CurrencyApi_npm_' + APPLICATION_VERSION
  * @param {Object} params
  * @returns {string}
  */
-const buildUrl = (endpoint, key, params = {}) => {
+const buildUrl = (endpoint, key, params) => {
     let ret = [];
     for (let param in params) {
         ret.push(encodeURIComponent(param) + '=' + encodeURIComponent(params[param]));
@@ -87,9 +75,12 @@ class Endpoint {
      * @returns {Promise<*>}
      */
     async get() {
-        const headers = {'application': APPLICATION, 'user-agent': APPLICATION}
-        const response = await client(buildUrl(this.endpoint, this.key, this.getParams()), {headers: headers})
         const isXml = this.getParams().output === 'XML'
+        let headers = {
+            'X-Sdk': 'node'
+        }
+        headers['Content-Type'] = isXml ? 'application/xml' : 'application/json'
+        const response = await fetch(buildUrl(this.endpoint, this.key, this.getParams()), {headers: headers})
         return isXml ? await response.text() : await response.json()
     }
 

package/tests/convert.test.js

@@ -0,0 +1,113 @@
+jest.mock("node-fetch")
+const fetch = require("node-fetch")
+const Convert = require('./../src/classes/Convert')
+
+let convert
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    convert = new Convert(invalidKey)
+})
+
+describe("Setting Convert", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(convert.key).toBe(invalidKey)
+        expect(convert.endpoint).toBe('convert')
+    })
+
+    test('Check default params have been set', () => {
+        let params = convert.getParams()
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set amount works and returns object', () => {
+        let expectedAmount = 100
+        const setAmount = convert.amount(expectedAmount)
+        let params = convert.getParams()
+        expect(params).toHaveProperty('amount', expectedAmount)
+        expect(setAmount).toBeInstanceOf(Convert)
+    })
+
+    test('Set to works and returns object', () => {
+        let expectedTo = 'gBp'
+        const setTo = convert.to(expectedTo)
+        let params = convert.getParams()
+        expect(params).toHaveProperty('to', 'GBP')
+        expect(setTo).toBeInstanceOf(Convert)
+    })
+
+    test('Set from works and returns object', () => {
+        let expectedFrom = 'BTc'
+        const setFrom = convert.from(expectedFrom)
+        let params = convert.getParams()
+        expect(params).toHaveProperty('from', 'BTC')
+        expect(setFrom).toBeInstanceOf(Convert)
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = convert.output('xMl')
+        let params = convert.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(Convert)
+    })
+})
+
+describe("Fetching convert works as expected", () => {
+
+    test("fetch json working as expected", async () => {
+
+        const mockData = {}
+        fetch.mockReturnValue(
+          Promise.resolve({
+            json: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        convert.amount(10)
+        convert.from('GbP')
+        convert.to('UsD')
+        const response = await convert.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/convert?key=invalidKey&output=JSON&amount=10&from=GBP&to=USD'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/json",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('output=JSON')
+        expect(expectedUrl).toContain('amount=10')
+        expect(expectedUrl).toContain('from=GBP')
+        expect(expectedUrl).toContain('to=USD')
+        expect(response).toEqual(mockData)
+    })
+
+    test("fetch xml working as expected", async () => {
+
+        const mockData = ''
+
+        fetch.mockReturnValue(
+          Promise.resolve({
+            text: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        convert.output('XmL')
+        convert.amount(10)
+        convert.from('GbP')
+        convert.to('UsD')
+        const response = await convert.get()
+
+        const expectedUrl = 'https://currencyapi.net/api/v1/convert?key=invalidKey&output=XML&amount=10&from=GBP&to=USD'
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/xml",
+            "X-Sdk": "node"
+        }
+        })
+        expect(response).toEqual(mockData);
+    })
+
+})

package/tests/currencies.test.js

@@ -0,0 +1,80 @@
+jest.mock("node-fetch")
+const fetch = require("node-fetch")
+const Currencies = require('./../src/classes/Currencies')
+
+let currencies
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    currencies = new Currencies(invalidKey)
+})
+
+describe("Setting Convert", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(currencies.key).toBe(invalidKey)
+        expect(currencies.endpoint).toBe('currencies')
+    })
+
+    test('Check default params have been set', () => {
+        let params = currencies.getParams()
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = currencies.output('xMl')
+        let params = currencies.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(Currencies)
+    })
+})
+
+describe("Fetching currencies works as expected", () => {
+
+    test("fetch json working as expected", async () => {
+
+        const mockData = {}
+        fetch.mockReturnValue(
+          Promise.resolve({
+            json: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        const response = await currencies.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/currencies?key=invalidKey&output=JSON'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/json",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('output=JSON')
+        expect(response).toEqual(mockData)
+    })
+
+    test("fetch xml working as expected", async () => {
+
+        const mockData = ''
+
+        fetch.mockReturnValue(
+          Promise.resolve({
+            text: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        currencies.output('XmL')
+        const response = await currencies.get()
+
+        const expectedUrl = 'https://currencyapi.net/api/v1/currencies?key=invalidKey&output=XML'
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/xml",
+            "X-Sdk": "node"
+        }
+        })
+        expect(response).toEqual(mockData);
+    })
+
+})

package/tests/currencyapi.test.js

@@ -0,0 +1,28 @@
+const CurrencyApi = require('./../src/CurrencyApi')
+const Rates = require('./../src/classes/Rates')
+const History = require('./../src/classes/History')
+const Timeframe = require('./../src/classes/Timeframe')
+const Convert = require('./../src/classes/Convert')
+const Currencies = require('./../src/classes/Currencies')
+
+let currencyApi
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    currencyApi = new CurrencyApi(invalidKey)
+})
+
+describe("Setting CurrencyApi", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(currencyApi.key).toBe(invalidKey);
+    })
+
+    test('Each CurrencyApi method is returning the relevant class', () => {
+        expect(currencyApi.rates()).toBeInstanceOf(Rates);
+        expect(currencyApi.history()).toBeInstanceOf(History);
+        expect(currencyApi.timeframe()).toBeInstanceOf(Timeframe);
+        expect(currencyApi.convert()).toBeInstanceOf(Convert);
+        expect(currencyApi.currencies()).toBeInstanceOf(Currencies);
+    })
+})

package/tests/endpoint.test.js

@@ -0,0 +1,31 @@
+const Endpoint = require('./../src/classes/Endpoint')
+
+
+let endpoint
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    endpoint = new Endpoint(invalidKey,'endpoint')
+})
+
+describe("Setting Endpoint", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(endpoint.key).toBe(invalidKey)
+        expect(endpoint.endpoint).toBe('endpoint');
+    })
+
+    test('Check default params have been set', () => {
+        let params = endpoint.getParams()
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = endpoint.output('xMl')
+        let params = endpoint.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(Endpoint)
+    })
+
+})

package/tests/history.test.js

@@ -0,0 +1,100 @@
+jest.mock("node-fetch")
+const fetch = require("node-fetch")
+const History = require('./../src/classes/History')
+
+let history
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    history = new History(invalidKey)
+})
+
+describe("Setting History", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(history.key).toBe(invalidKey)
+        expect(history.endpoint).toBe('history')
+    })
+
+    test('Check default params have been set', () => {
+        let params = history.getParams()
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set date works and returns object', () => {
+        let expectedDate = '2023-10-10'
+        const setDate = history.date(expectedDate)
+        let params = history.getParams()
+        expect(params).toHaveProperty('date', expectedDate)
+        expect(setDate).toBeInstanceOf(History)
+    })
+
+    test('Set base works and returns object', () => {
+        let expectedBase = 'GBP'
+        const setBase = history.base('gBp')
+        let params = history.getParams()
+        expect(params).toHaveProperty('base', expectedBase)
+        expect(setBase).toBeInstanceOf(History)
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = history.output('xMl')
+        let params = history.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(History)
+    })
+})
+
+describe("Fetching history works as expected", () => {
+
+    test("fetch json working as expected", async () => {
+
+        const mockData = {}
+        fetch.mockReturnValue(
+          Promise.resolve({
+            json: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        history.date('2023-01-02')
+        const response = await history.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/history?key=invalidKey&output=JSON&base=USD&date=2023-01-02'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/json",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('date=2023-01-02')
+        expect(response).toEqual(mockData)
+    })
+
+    test("fetch xml working as expected", async () => {
+
+        const mockData = ''
+
+        fetch.mockReturnValue(
+          Promise.resolve({
+            text: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        history.output('xmL')
+        history.date('2023-01-02')
+        history.base('GbP')
+        const response = await history.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/history?key=invalidKey&output=XML&base=GBP&date=2023-01-02'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/xml",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('date=2023-01-02')
+        expect(response).toEqual(mockData);
+    })
+
+})

package/tests/rates.test.js

@@ -0,0 +1,103 @@
+jest.mock("node-fetch")
+const fetch = require("node-fetch")
+const Rates = require('./../src/classes/Rates')
+
+let rates
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    rates = new Rates(invalidKey)
+})
+
+describe("Setting Rates", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(rates.key).toBe(invalidKey)
+        expect(rates.endpoint).toBe('rates')
+    })
+
+    test('Check default params have been set', () => {
+        let params = rates.getParams()
+        expect(params).toHaveProperty('base', 'USD')
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set base works and returns object', () => {
+        let expectedBase = 'GBP'
+        const setBase = rates.base('gBp')
+        let params = rates.getParams()
+        expect(params).toHaveProperty('base', expectedBase)
+        expect(setBase).toBeInstanceOf(Rates)
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = rates.output('xMl')
+        let params = rates.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(Rates)
+    })
+
+    
+})
+
+describe("Fetching rates works as expected", () => {
+
+    test("fetch json working as expected", async () => {
+
+        const mockData = {
+            "valid": true,
+            "updated": 1695542403,
+            "base": "USD",
+            "rates": {
+                    "AED": 3.673,
+                    "AFN": 78.58716,
+                    "ALL": 99.73298,
+            }
+        }
+        fetch.mockReturnValue(
+          Promise.resolve({
+            json: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        const response = await rates.get();
+        expect(fetch).toHaveBeenLastCalledWith("https://currencyapi.net/api/v1/rates?key=invalidKey&output=JSON&base=USD", {
+          headers: { 
+            "Content-Type": "application/json",
+            "X-Sdk": "node"
+        }
+        })
+        expect(response).toEqual(mockData);
+      })
+
+    test("fetch xml working as expected", async () => {
+
+        const mockData = `<?xml version='1.0' encoding='utf-8'?>
+        <root>
+        <valid></valid>
+        <error>
+        <code>401</code>
+        <message>Your API key is not valid</message>
+        </error>
+        </root>`
+
+        fetch.mockReturnValue(
+          Promise.resolve({
+            text: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        rates.output('XmL')
+        const response = await rates.get()
+
+        expect(fetch).toHaveBeenLastCalledWith("https://currencyapi.net/api/v1/rates?key=invalidKey&output=XML&base=USD", {
+          headers: { 
+            "Content-Type": "application/xml",
+            "X-Sdk": "node"
+        }
+        })
+        expect(response).toEqual(mockData);
+    })
+
+})

package/tests/timeframe.test.js

@@ -0,0 +1,112 @@
+jest.mock("node-fetch")
+const fetch = require("node-fetch")
+const Timeframe = require('./../src/classes/Timeframe')
+
+let timeframe
+let invalidKey = 'invalidKey'
+
+beforeEach(() => {
+    timeframe = new Timeframe(invalidKey)
+})
+
+
+describe("Setting Timeframe", () => {
+
+    test('Constructor setting params correctly', () => {
+        expect(timeframe.key).toBe(invalidKey)
+        expect(timeframe.endpoint).toBe('timeframe')
+    })
+
+    test('Check default params have been set', () => {
+        let params = timeframe.getParams()
+        expect(params).toHaveProperty('output', 'JSON')
+    })
+
+    test('Set base works and returns object', () => {
+        let expectedBase = 'GBP'
+        const setBase = timeframe.base('gBp')
+        let params = timeframe.getParams()
+        expect(params).toHaveProperty('base', expectedBase)
+        expect(setBase).toBeInstanceOf(Timeframe)
+    })
+
+    test('Set start date works and returns object', () => {
+        let expectedStart = '2023-01-02'
+        const setStart = timeframe.startDate(expectedStart)
+        let params = timeframe.getParams()
+        expect(params).toHaveProperty('start_date', expectedStart)
+        expect(setStart).toBeInstanceOf(Timeframe)
+    })
+
+    test('Set end date works and returns object', () => {
+        let expectedEnd = '2023-01-06'
+        const setEnd = timeframe.endDate(expectedEnd)
+        let params = timeframe.getParams()
+        expect(params).toHaveProperty('end_date', expectedEnd)
+        expect(setEnd).toBeInstanceOf(Timeframe)
+    })
+
+    test('Set output works and returns object', () => {
+        let expectedOutput = 'XML'
+        const setBase = timeframe.output('xMl')
+        let params = timeframe.getParams()
+        expect(params).toHaveProperty('output', expectedOutput)
+        expect(setBase).toBeInstanceOf(Timeframe)
+    })
+})
+
+describe("Fetching timeframe works as expected", () => {
+
+    test("fetch json working as expected", async () => {
+
+        const mockData = {}
+        fetch.mockReturnValue(
+          Promise.resolve({
+            json: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        timeframe.startDate('2023-01-02')
+        timeframe.endDate('2023-01-03')
+        const response = await timeframe.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/timeframe?key=invalidKey&output=JSON&base=USD&start_date=2023-01-02&end_date=2023-01-03'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/json",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('start_date=2023-01-02')
+        expect(expectedUrl).toContain('end_date=2023-01-03')
+        expect(response).toEqual(mockData)
+    })
+
+    test("fetch xml working as expected", async () => {
+
+        const mockData = ''
+
+        fetch.mockReturnValue(
+          Promise.resolve({
+            text: () =>
+              Promise.resolve(mockData)
+          })
+        )
+        timeframe.output('xMl')
+        timeframe.startDate('2023-01-02')
+        timeframe.endDate('2023-01-03')
+        const response = await timeframe.get();
+        const expectedUrl = 'https://currencyapi.net/api/v1/timeframe?key=invalidKey&output=XML&base=USD&start_date=2023-01-02&end_date=2023-01-03'
+
+        expect(fetch).toHaveBeenLastCalledWith(expectedUrl, {
+          headers: { 
+            "Content-Type": "application/xml",
+            "X-Sdk": "node"
+        }
+        })
+        expect(expectedUrl).toContain('start_date=2023-01-02')
+        expect(expectedUrl).toContain('end_date=2023-01-03')
+        expect(response).toEqual(mockData);
+    })
+
+})