export const pizzaReducer: ActionReducer<Object> = (state = defaultState, action: Action) => {
  switch (action.type) {
    case PizzaActions.CREATE_NEW_PIZZA: {
      return Object.assign({}, defaultState, { id: uuid() })
    }

    case PizzaActions.UPDATE_PIZZA: {
      let updatedIngredient = {}
      const currentSelection = state.ingredients[state.step]

      if (currentSelection instanceof Array && action.payload.checked) {
        updatedIngredient[state.step] = [ ...currentSelection, action.payload.value ]
      } else if (currentSelection instanceof Array && !action.payload.checked) {
        updatedIngredient[state.step] = currentSelection.filter(i => i !== action.payload.value)
      } else {
        updatedIngredient[state.step] = action.payload.value
      }

      const ingredients = Object.assign({}, state.ingredients, updatedIngredient)
      let price = 7.99 + ingredients.meat.length * 1.99 + ingredients.veggies.length * 0.99

      switch (ingredients.cheese) {
      case 'None': price -= 1.70; break
      case 'Light': price -= 0.85; break
      case 'Extra': price += 1.30; break
      }

      if (ingredients.crust === 'Gluten Free') {
        price += 2.50
      }

      return Object.assign({}, state, { ingredients, price })
    }

    case PizzaActions.NEXT_STEP: {
      const index = steps.indexOf(state.step) + 1
      const step = steps[Math.min(index, steps.length - 1)]
      return Object.assign({}, state, { step })
    }

    case PizzaActions.PREVIOUS_STEP: {
      const index = steps.indexOf(state.step) - 1
      const step = steps[Math.max(index, 0)]
      return Object.assign({}, state, { step })
    }

    default: return state
  }
}

  test('getDeviceInvalidQueryInvalidDeviceId', async () => {

    const getDeviceVariablesInvalidDeviceId  = {
      deviceId: uuidv4(),
    }
    await expect(gqlRequest(getDeviceInvalidQuery, getDeviceVariablesInvalidDeviceId)).rejects.toThrow()
  });

    test('a delivery confirmation is built', async function(assert) {
      assert.expect(5);

      const me = getService<CurrentUserService>('currentUser');

      await me.exists();

      const store = getService<StoreService>('store');
      const service = getService<AutoResponder>('messages/auto-responder');

      const sender = await createContact('some user');
      const receivedMessage = store.createRecord('message', {
        id: uuid(),
        sender,
        body: 'test message',
      });

      stubService('messages/dispatcher', {
        sendToUser: {
          perform(response: Message, to: Identity) {
            assert.equal(response.target, TARGET.MESSAGE);
            assert.equal(response.type, TYPE.DELIVERY_CONFIRMATION);
            assert.equal(response.to, receivedMessage.id);
            assert.equal(response.sender, me.record);
            assert.equal(to.publicKey, sender.publicKey);
          },
        },
      });

      service.messageReceived(receivedMessage);
    });

  .get('/fetchInfo', ctx => {
    const { user } = ctx.session
    let sessionID

    if (!user) {
      sessionID = uuid()
      ctx.session.uuid = sessionID
    }

    ctx.body = {
      user: user || {
        uuid: sessionID,
      },
      envs: ENV_KEYS.reduce((envs, key) => {
        let value: string | string[] = process.env[key]

        if (STR_ARR_ENV_KEYS.includes(key)) {
          value = value ? value.split(',') : []
        }

        return Object.assign(envs, {
          [key]: process.env[key],
        })
      }, {}),
    }
  })

 private build(attributes = {}) {
   return this.store.createRecord('message', {
     id: uuid(),
     sentAt: new Date(),
     from: this.currentUser.uid,
     sender: this.currentUser.record,
     ...attributes,
   });
 }

 ngOnInit() {
   this.userToken = this.cookieService.get('userToken');
   if (!this.userToken) {
     this.userToken = uuid();
     const date = new Date();
     date.setTime(date.getTime() + (5000 * 24 * 60 * 60 * 1000));
     this.cookieService.set('userToken', this.userToken, date);
   }
 }

    fieldResolver: ((source, _args, _context, info) => {
      const pathAsArray = responsePathAsArray(info.path)
      if (pathAsArray.length === 1) {
        // source is null for root fields
        source = source || (info.operation.operation === "mutation" ? mockMutationResults : mockData)
      }

      // fail early if source is not an object type
      // this happens because graphql only checks for null when deciding
      // whether to resolve fields in a given value
      if (typeof source !== "object") {
        const parentPath = pathAsArray.slice(0, -1).join("/")
        throw new Error(`The value at path '${parentPath}' should be an object but is a ${typeof source}.`)
      }

      // handle aliased fields first
      const alias = info.fieldNodes[0].alias
      if (alias && alias.value in source) {
        return inferUnionOrInterfaceType(checkLeafType(source[alias.value], info), info)
      }

      // the common case, the field has a fixture and is not aliased
      if (info.fieldName in source) {
        return inferUnionOrInterfaceType(checkLeafType(source[info.fieldName], info), info)
      }

      if (info.fieldName === "__id" || info.fieldName === "id") {
        // if relay is looking for `__id` but we only supplied `id`
        if ("id" in source) {
          return source.id
        }

        // relay is looking for an id to denormalize the fixture in the store
        // but we don't want to have to specify ids for all fixtures
        // so generate one and store it in a weak map so we don't mutate
        // the object itself
        if (idMap.has(source)) {
          return idMap.get(source)
        }

        const id = uuid()
        idMap.set(source, id)
        return id
      }

      throw error(
        info,
        ({ type, path }) => `A mock for field at path '${path}' of type '${type}' was expected but not found.`
      )
    }) as GraphQLFieldResolver<any, any>,

  test('getDeviceAndMessagesValidQueryDoesNotExist', async () => {

    const getDeviceVariablesInvalidDeviceId  = {
      deviceId: uuidv4(),
    }

    const expectedNullResponse = {
      "getDevice": null
    }

    return gqlRequest(getDeviceAndMessagesQuery, getDeviceVariablesInvalidDeviceId)
        .then(result => {
          expect(result).toEqual(expectedNullResponse)
        })
  });

function* showNotification(title, uuids) {
  //Show a toastr notification. Return its notifyId
  //Select vm names from store by uuids
  const selector = (state) => state.get('app').get('vm_data');
  const vm_data_map = yield select(selector);
  const names = uuids.map(uuid => vm_data_map.get(uuid).name_label);
  //Set up notification options
  const options = {
    id: uuid(),
    type: 'info',
    timeOut: 0,
    title,
    message: names.join('\n'),
    options: {
      showCloseButton: true,
    }
  };
  yield put(actions.add(options));
  return options.id;
}