text: import assert from 'assert'
  import sinon from 'sinon'
  import proxyquire from 'proxyquire'
  
  const fakeLocalStorage = {}
  
  const GasDuck = proxyquire('./gas.duck.js', {
    '../../../lib/local-storage-helpers': fakeLocalStorage,
  })
  
  const {
    basicGasEstimatesLoadingStarted,
    basicGasEstimatesLoadingFinished,
    setBasicGasEstimateData,
    setCustomGasPrice,
    setCustomGasLimit,
    setCustomGasTotal,
    setCustomGasErrors,
    resetCustomGasState,
    fetchBasicGasAndTimeEstimates,
    fetchBasicGasEstimates,
    gasEstimatesLoadingStarted,
    gasEstimatesLoadingFinished,
    setPricesAndTimeEstimates,
    fetchGasEstimates,
    setApiEstimatesLastRetrieved,
  } = GasDuck
  const GasReducer = GasDuck.default
  
  describe('Gas Duck', function () {
    let tempFetch
    let tempDateNow
    const mockEthGasApiResponse = {
      average: 20,
      avgWait: 'mockAvgWait',
      block_time: 'mockBlock_time',
      blockNum: 'mockBlockNum',
      fast: 30,
      fastest: 40,
      fastestWait: 'mockFastestWait',
      fastWait: 'mockFastWait',
      safeLow: 10,
      safeLowWait: 'mockSafeLowWait',
      speed: 'mockSpeed',
      standard: 20,
    }
    const mockPredictTableResponse = [
      { expectedTime: 400, expectedWait: 40, gasprice: 0.25, somethingElse: 'foobar' },
      { expectedTime: 200, expectedWait: 20, gasprice: 0.5, somethingElse: 'foobar' },
      { expectedTime: 100, expectedWait: 10, gasprice: 1, somethingElse: 'foobar' },
      { expectedTime: 75, expectedWait: 7.5, gasprice: 1.5, somethingElse: 'foobar' },
      { expectedTime: 50, expectedWait: 5, gasprice: 2, somethingElse: 'foobar' },
      { expectedTime: 35, expectedWait: 4.5, gasprice: 3, somethingElse: 'foobar' },
      { expectedTime: 34, expectedWait: 4.4, gasprice: 3.1, somethingElse: 'foobar' },
      { expectedTime: 25, expectedWait: 4.2, gasprice: 3.5, somethingElse: 'foobar' },
      { expectedTime: 20, expectedWait: 4, gasprice: 4, somethingElse: 'foobar' },
      { expectedTime: 19, expectedWait: 3.9, gasprice: 4.1, somethingElse: 'foobar' },
      { expectedTime: 15, expectedWait: 3, gasprice: 7, somethingElse: 'foobar' },
      { expectedTime: 14, expectedWait: 2.9, gasprice: 7.1, somethingElse: 'foobar' },
      { expectedTime: 12, expectedWait: 2.5, gasprice: 8, somethingElse: 'foobar' },
      { expectedTime: 10, expectedWait: 2, gasprice: 10, somethingElse: 'foobar' },
      { expectedTime: 9, expectedWait: 1.9, gasprice: 10.1, somethingElse: 'foobar' },
      { expectedTime: 5, expectedWait: 1, gasprice: 15, somethingElse: 'foobar' },
      { expectedTime: 4, expectedWait: 0.9, gasprice: 15.1, somethingElse: 'foobar' },
      { expectedTime: 2, expectedWait: 0.8, gasprice: 17, somethingElse: 'foobar' },
      { expectedTime: 1.1, expectedWait: 0.6, gasprice: 19.9, somethingElse: 'foobar' },
      { expectedTime: 1, expectedWait: 0.5, gasprice: 20, somethingElse: 'foobar' },
    ]
    const fakeFetch = (url) => new Promise((resolve) => {
      const dataToResolve = url.match(/ethgasAPI/)
        ? mockEthGasApiResponse
        : mockPredictTableResponse
      resolve({
        json: () => new Promise((resolve) => resolve(dataToResolve)),
      })
    })
  
    beforeEach(function () {
      tempFetch = window.fetch
      tempDateNow = global.Date.now
  
      fakeLocalStorage.loadLocalStorageData = sinon.stub()
      fakeLocalStorage.saveLocalStorageData = sinon.spy()
      window.fetch = sinon.stub().callsFake(fakeFetch)
      global.Date.now = () => 2000000
    })
  
    afterEach(function () {
      sinon.restore()
  
      window.fetch = tempFetch
      global.Date.now = tempDateNow
    })
  
    const mockState = {
      mockProp: 123,
    }
    const initState = {
      customData: {
        price: null,
        limit: null,
      },
      basicEstimates: {
        average: null,
        fastestWait: null,
        fastWait: null,
        fast: null,
        safeLowWait: null,
        blockNum: null,
        avgWait: null,
        blockTime: null,
        speed: null,
        fastest: null,
        safeLow: null,
      },
      basicEstimateIsLoading: true,
      errors: {},
      gasEstimatesLoading: true,
      priceAndTimeEstimates: [],
      priceAndTimeEstimatesLastRetrieved: 0,
      basicPriceAndTimeEstimatesLastRetrieved: 0,
      basicPriceEstimatesLastRetrieved: 0,
    }
    const BASIC_GAS_ESTIMATE_LOADING_FINISHED = 'metamask/gas/BASIC_GAS_ESTIMATE_LOADING_FINISHED'
    const BASIC_GAS_ESTIMATE_LOADING_STARTED = 'metamask/gas/BASIC_GAS_ESTIMATE_LOADING_STARTED'
    const GAS_ESTIMATE_LOADING_FINISHED = 'metamask/gas/GAS_ESTIMATE_LOADING_FINISHED'
    const GAS_ESTIMATE_LOADING_STARTED = 'metamask/gas/GAS_ESTIMATE_LOADING_STARTED'
    const RESET_CUSTOM_GAS_STATE = 'metamask/gas/RESET_CUSTOM_GAS_STATE'
    const SET_BASIC_GAS_ESTIMATE_DATA = 'metamask/gas/SET_BASIC_GAS_ESTIMATE_DATA'
    const SET_CUSTOM_GAS_ERRORS = 'metamask/gas/SET_CUSTOM_GAS_ERRORS'
    const SET_CUSTOM_GAS_LIMIT = 'metamask/gas/SET_CUSTOM_GAS_LIMIT'
    const SET_CUSTOM_GAS_PRICE = 'metamask/gas/SET_CUSTOM_GAS_PRICE'
    const SET_CUSTOM_GAS_TOTAL = 'metamask/gas/SET_CUSTOM_GAS_TOTAL'
    const SET_PRICE_AND_TIME_ESTIMATES = 'metamask/gas/SET_PRICE_AND_TIME_ESTIMATES'
    const SET_API_ESTIMATES_LAST_RETRIEVED = 'metamask/gas/SET_API_ESTIMATES_LAST_RETRIEVED'
    const SET_BASIC_API_ESTIMATES_LAST_RETRIEVED = 'metamask/gas/SET_BASIC_API_ESTIMATES_LAST_RETRIEVED'
    const SET_BASIC_PRICE_ESTIMATES_LAST_RETRIEVED = 'metamask/gas/SET_BASIC_PRICE_ESTIMATES_LAST_RETRIEVED'
  
    describe('GasReducer()', function () {
      it('should initialize state', function () {
        assert.deepEqual(GasReducer(undefined, {}), initState)
      })
  
      it('should return state unchanged if it does not match a dispatched actions type', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: 'someOtherAction',
            value: 'someValue',
          }),
          mockState,
        )
      })
  
      it('should set basicEstimateIsLoading to true when receiving a BASIC_GAS_ESTIMATE_LOADING_STARTED action', function () {
        assert.deepEqual(
          GasReducer(mockState, { type: BASIC_GAS_ESTIMATE_LOADING_STARTED }),
          { basicEstimateIsLoading: true, ...mockState },
        )
      })
  
      it('should set basicEstimateIsLoading to false when receiving a BASIC_GAS_ESTIMATE_LOADING_FINISHED action', function () {
        assert.deepEqual(
          GasReducer(mockState, { type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }),
          { basicEstimateIsLoading: false, ...mockState },
        )
      })
  
      it('should set gasEstimatesLoading to true when receiving a GAS_ESTIMATE_LOADING_STARTED action', function () {
        assert.deepEqual(
          GasReducer(mockState, { type: GAS_ESTIMATE_LOADING_STARTED }),
          { gasEstimatesLoading: true, ...mockState },
        )
      })
  
      it('should set gasEstimatesLoading to false when receiving a GAS_ESTIMATE_LOADING_FINISHED action', function () {
        assert.deepEqual(
          GasReducer(mockState, { type: GAS_ESTIMATE_LOADING_FINISHED }),
          { gasEstimatesLoading: false, ...mockState },
        )
      })
  
      it('should set basicEstimates when receiving a SET_BASIC_GAS_ESTIMATE_DATA action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: { someProp: 'someData123' },
          }),
          { basicEstimates: { someProp: 'someData123' }, ...mockState },
        )
      })
  
      it('should set priceAndTimeEstimates when receiving a SET_PRICE_AND_TIME_ESTIMATES action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_PRICE_AND_TIME_ESTIMATES,
            value: { someProp: 'someData123' },
          }),
          { priceAndTimeEstimates: { someProp: 'someData123' }, ...mockState },
        )
      })
  
      it('should set customData.price when receiving a SET_CUSTOM_GAS_PRICE action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_CUSTOM_GAS_PRICE,
            value: 4321,
          }),
          { customData: { price: 4321 }, ...mockState },
        )
      })
  
      it('should set customData.limit when receiving a SET_CUSTOM_GAS_LIMIT action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_CUSTOM_GAS_LIMIT,
            value: 9876,
          }),
          { customData: { limit: 9876 }, ...mockState },
        )
      })
  
      it('should set customData.total when receiving a SET_CUSTOM_GAS_TOTAL action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_CUSTOM_GAS_TOTAL,
            value: 10000,
          }),
          { customData: { total: 10000 }, ...mockState },
        )
      })
  
      it('should set priceAndTimeEstimatesLastRetrieved when receiving a SET_API_ESTIMATES_LAST_RETRIEVED action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_API_ESTIMATES_LAST_RETRIEVED,
            value: 1500000000000,
          }),
          { priceAndTimeEstimatesLastRetrieved: 1500000000000, ...mockState },
        )
      })
  
      it('should set priceAndTimeEstimatesLastRetrieved when receiving a SET_BASIC_API_ESTIMATES_LAST_RETRIEVED action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_BASIC_API_ESTIMATES_LAST_RETRIEVED,
            value: 1700000000000,
          }),
          { basicPriceAndTimeEstimatesLastRetrieved: 1700000000000, ...mockState },
        )
      })
  
      it('should set errors when receiving a SET_CUSTOM_GAS_ERRORS action', function () {
        assert.deepEqual(
          GasReducer(mockState, {
            type: SET_CUSTOM_GAS_ERRORS,
            value: { someError: 'error_error' },
          }),
          { errors: { someError: 'error_error' }, ...mockState },
        )
      })
  
      it('should return the initial state in response to a RESET_CUSTOM_GAS_STATE action', function () {
        assert.deepEqual(
          GasReducer(mockState, { type: RESET_CUSTOM_GAS_STATE }),
          initState,
        )
      })
    })
  
    describe('basicGasEstimatesLoadingStarted', function () {
      it('should create the correct action', function () {
        assert.deepEqual(basicGasEstimatesLoadingStarted(), { type: BASIC_GAS_ESTIMATE_LOADING_STARTED })
      })
    })
  
    describe('basicGasEstimatesLoadingFinished', function () {
      it('should create the correct action', function () {
        assert.deepEqual(basicGasEstimatesLoadingFinished(), { type: BASIC_GAS_ESTIMATE_LOADING_FINISHED })
      })
    })
  
    describe('fetchBasicGasEstimates', function () {
      it('should call fetch with the expected params', async function () {
        const mockDistpatch = sinon.spy()
  
        await fetchBasicGasEstimates()(mockDistpatch, () => ({
          gas: { ...initState, basicPriceAEstimatesLastRetrieved: 1000000 },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(
          window.fetch.getCall(0).args[0].startsWith('https://ethgasstation.info/json/ethgasAPI.json'),
          'should fetch ETH Gas Station',
        )
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{ type: SET_BASIC_PRICE_ESTIMATES_LAST_RETRIEVED, value: 2000000 } ],
        )
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 2,
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 3,
              fastest: 4,
              safeLow: 1,
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(3).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
  
      it('should fetch recently retrieved estimates from local storage', async function () {
        const mockDistpatch = sinon.spy()
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_PRICE_ESTIMATES_LAST_RETRIEVED')
          .returns(2000000 - 1) // one second ago from "now"
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_PRICE_ESTIMATES')
          .returns({
            average: 25,
            blockTime: 'mockBlock_time',
            blockNum: 'mockBlockNum',
            fast: 35,
            fastest: 45,
            safeLow: 15,
          })
  
        await fetchBasicGasEstimates()(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          {},
        ) }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(window.fetch.notCalled)
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 25,
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 35,
              fastest: 45,
              safeLow: 15,
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
  
      it('should fallback to network if retrieving estimates from local storage fails', async function () {
        const mockDistpatch = sinon.spy()
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_PRICE_ESTIMATES_LAST_RETRIEVED')
          .returns(2000000 - 1) // one second ago from "now"
  
        await fetchBasicGasEstimates()(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          {},
        ) }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(
          window.fetch.getCall(0).args[0].startsWith('https://ethgasstation.info/json/ethgasAPI.json'),
          'should fetch ETH Gas Station',
        )
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{ type: SET_BASIC_PRICE_ESTIMATES_LAST_RETRIEVED, value: 2000000 } ],
        )
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 2,
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 3,
              fastest: 4,
              safeLow: 1,
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(3).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
    })
  
    describe('fetchBasicGasAndTimeEstimates', function () {
      it('should call fetch with the expected params', async function () {
        const mockDistpatch = sinon.spy()
  
        await fetchBasicGasAndTimeEstimates()(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          { basicPriceAndTimeEstimatesLastRetrieved: 1000000 },
        ),
        metamask: { provider: { type: 'ropsten' } },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(
          window.fetch.getCall(0).args[0].startsWith('https://ethgasstation.info/json/ethgasAPI.json'),
          'should fetch ETH Gas Station',
        )
  
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{ type: SET_BASIC_API_ESTIMATES_LAST_RETRIEVED, value: 2000000 } ],
        )
  
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 2,
              avgWait: 'mockAvgWait',
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 3,
              fastest: 4,
              fastestWait: 'mockFastestWait',
              fastWait: 'mockFastWait',
              safeLow: 1,
              safeLowWait: 'mockSafeLowWait',
              speed: 'mockSpeed',
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(3).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
  
      it('should fetch recently retrieved estimates from local storage', async function () {
        const mockDistpatch = sinon.spy()
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_GAS_AND_TIME_API_ESTIMATES_LAST_RETRIEVED')
          .returns(2000000 - 1) // one second ago from "now"
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_GAS_AND_TIME_API_ESTIMATES')
          .returns({
            average: 5,
            avgWait: 'mockAvgWait',
            blockTime: 'mockBlock_time',
            blockNum: 'mockBlockNum',
            fast: 6,
            fastest: 7,
            fastestWait: 'mockFastestWait',
            fastWait: 'mockFastWait',
            safeLow: 1,
            safeLowWait: 'mockSafeLowWait',
            speed: 'mockSpeed',
          })
  
        await fetchBasicGasAndTimeEstimates()(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          {},
        ),
        metamask: { provider: { type: 'ropsten' } },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(window.fetch.notCalled)
  
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 5,
              avgWait: 'mockAvgWait',
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 6,
              fastest: 7,
              fastestWait: 'mockFastestWait',
              fastWait: 'mockFastWait',
              safeLow: 1,
              safeLowWait: 'mockSafeLowWait',
              speed: 'mockSpeed',
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
  
      it('should fallback to network if retrieving estimates from local storage fails', async function () {
        const mockDistpatch = sinon.spy()
        fakeLocalStorage.loadLocalStorageData
          .withArgs('BASIC_GAS_AND_TIME_API_ESTIMATES_LAST_RETRIEVED')
          .returns(2000000 - 1) // one second ago from "now"
  
        await fetchBasicGasAndTimeEstimates()(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          {},
        ),
        metamask: { provider: { type: 'ropsten' } },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(
          window.fetch.getCall(0).args[0].startsWith('https://ethgasstation.info/json/ethgasAPI.json'),
          'should fetch ETH Gas Station',
        )
  
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{ type: SET_BASIC_API_ESTIMATES_LAST_RETRIEVED, value: 2000000 } ],
        )
  
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{
            type: SET_BASIC_GAS_ESTIMATE_DATA,
            value: {
              average: 2,
              avgWait: 'mockAvgWait',
              blockTime: 'mockBlock_time',
              blockNum: 'mockBlockNum',
              fast: 3,
              fastest: 4,
              fastestWait: 'mockFastestWait',
              fastWait: 'mockFastWait',
              safeLow: 1,
              safeLowWait: 'mockSafeLowWait',
              speed: 'mockSpeed',
            },
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(3).args,
          [{ type: BASIC_GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
    })
  
    describe('fetchGasEstimates', function () {
      it('should call fetch with the expected params', async function () {
        const mockDistpatch = sinon.spy()
  
        await fetchGasEstimates(5)(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          { priceAndTimeEstimatesLastRetrieved: 1000000 },
        ),
        metamask: { provider: { type: 'ropsten' } },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.ok(
          window.fetch.getCall(0).args[0].startsWith('https://ethgasstation.info/json/predictTable.json'),
          'should fetch ETH Gas Station',
        )
  
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{ type: SET_API_ESTIMATES_LAST_RETRIEVED, value: 2000000 }],
        )
  
        const { type: thirdDispatchCallType, value: priceAndTimeEstimateResult } = mockDistpatch.getCall(2).args[0]
        assert.equal(thirdDispatchCallType, SET_PRICE_AND_TIME_ESTIMATES)
        assert(priceAndTimeEstimateResult.length < ((mockPredictTableResponse.length * 3) - 2))
        assert(!priceAndTimeEstimateResult.find((d) => d.expectedTime > 100))
        assert(!priceAndTimeEstimateResult.find((d, _, a) => a[a + 1] && d.expectedTime > a[a + 1].expectedTime))
        assert(!priceAndTimeEstimateResult.find((d, _, a) => a[a + 1] && d.gasprice > a[a + 1].gasprice))
  
        assert.deepEqual(
          mockDistpatch.getCall(3).args,
          [{ type: GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
  
      it('should not call fetch if the estimates were retrieved < 75000 ms ago', async function () {
        const mockDistpatch = sinon.spy()
  
        await fetchGasEstimates(5)(mockDistpatch, () => ({ gas: Object.assign(
          {},
          initState,
          {
            priceAndTimeEstimatesLastRetrieved: Date.now(),
            priceAndTimeEstimates: [{
              expectedTime: '10',
              expectedWait: 2,
              gasprice: 50,
            }],
          },
        ),
        metamask: { provider: { type: 'ropsten' } },
        }))
        assert.deepEqual(
          mockDistpatch.getCall(0).args,
          [{ type: GAS_ESTIMATE_LOADING_STARTED } ],
        )
        assert.equal(window.fetch.callCount, 0)
  
        assert.deepEqual(
          mockDistpatch.getCall(1).args,
          [{
            type: SET_PRICE_AND_TIME_ESTIMATES,
            value: [
              {
                expectedTime: '10',
                expectedWait: 2,
                gasprice: 50,
              },
            ],
  
          }],
        )
        assert.deepEqual(
          mockDistpatch.getCall(2).args,
          [{ type: GAS_ESTIMATE_LOADING_FINISHED }],
        )
      })
    })
  
    describe('gasEstimatesLoadingStarted', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          gasEstimatesLoadingStarted(),
          { type: GAS_ESTIMATE_LOADING_STARTED },
        )
      })
    })
  
    describe('gasEstimatesLoadingFinished', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          gasEstimatesLoadingFinished(),
          { type: GAS_ESTIMATE_LOADING_FINISHED },
        )
      })
    })
  
    describe('setPricesAndTimeEstimates', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setPricesAndTimeEstimates('mockPricesAndTimeEstimates'),
          { type: SET_PRICE_AND_TIME_ESTIMATES, value: 'mockPricesAndTimeEstimates' },
        )
      })
    })
  
    describe('setBasicGasEstimateData', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setBasicGasEstimateData('mockBasicEstimatData'),
          { type: SET_BASIC_GAS_ESTIMATE_DATA, value: 'mockBasicEstimatData' },
        )
      })
    })
  
    describe('setCustomGasPrice', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setCustomGasPrice('mockCustomGasPrice'),
          { type: SET_CUSTOM_GAS_PRICE, value: 'mockCustomGasPrice' },
        )
      })
    })
  
    describe('setCustomGasLimit', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setCustomGasLimit('mockCustomGasLimit'),
          { type: SET_CUSTOM_GAS_LIMIT, value: 'mockCustomGasLimit' },
        )
      })
    })
  
    describe('setCustomGasTotal', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setCustomGasTotal('mockCustomGasTotal'),
          { type: SET_CUSTOM_GAS_TOTAL, value: 'mockCustomGasTotal' },
        )
      })
    })
  
    describe('setCustomGasErrors', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setCustomGasErrors('mockErrorObject'),
          { type: SET_CUSTOM_GAS_ERRORS, value: 'mockErrorObject' },
        )
      })
    })
  
    describe('setApiEstimatesLastRetrieved', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          setApiEstimatesLastRetrieved(1234),
          { type: SET_API_ESTIMATES_LAST_RETRIEVED, value: 1234 },
        )
      })
    })
  
    describe('resetCustomGasState', function () {
      it('should create the correct action', function () {
        assert.deepEqual(
          resetCustomGasState(),
          { type: RESET_CUSTOM_GAS_STATE },
        )
      })
    })
  
  })
  