module('computedDecorator', function() {

    test('it works', function(assert) {
      let decorate = computedDecorator((target, key, { get, set }) => {
        return computed({ get, set });
      });

      class Foo {
        @decorate
        get foo() {
          return 'bar';
        }

        set foo(value) {}
      }

      assert.ok(isComputedDescriptor(computedDescriptorFor(Foo.prototype, 'foo')), 'descriptor correctly assigned');
    });

    test('it passes in the previous computed descriptor if it exists', function(assert) {
      let decorate = computedDecorator((target, key, { get, set }) => {
        return computed({ get, set });
      });

      let decorateAgain = computedDecorator((target, key, desc) => {
        assert.ok(isComputedDescriptor(desc), 'computed descriptor passed in correctly');

        return desc;
      });

      class Foo {
        @decorateAgain
        @decorate
        get foo() {
          return 'bar';
        }

        set foo(value) {}
      }

      new Foo();
    });

    test('it throws if the decorator does not return a CP descriptor', function(assert) {
      assert.throws(
        () => {
          let decorate = computedDecorator((target, key, desc) => {
            return desc;
          });

          class Foo {
            @decorate
            get foo() {
              return 'bar';
            }

            set foo(value) {}
          }

          new Foo();
        },
        /computed decorators must return an instance of an Ember ComputedProperty descriptor/
      );
    });
  });

moduleForAcceptance('Acceptance | Events | Shirts | Viewing', {
  beforeEach() { mockSetup({ logLevel: 1, mockjaxLogLevel: 4 }); },
  afterEach() { mockTeardown(); }
});

test('a list of shirts', withChai(async expect => {
  authenticateSession();

  const event = make('event');
  const shirts = makeList('shirt', 2);

  mockQuery('shirt').returns({ models: shirts });
  mockFindRecord('event').returns({ model: event });

  await visit(`/dashboard/events/${event.id}/shirts`);

  expect(currentRouteName()).to.equal('events.show.shirts.index');

  const selector = '[data-test-shirts-list]';
  const list = find(selector);

  expect(list).to.be.ok
  expect(list.find('tr').length).to.equal(2);
}));

test('a single shirt with purchases', withChai(async expect => {
  authenticateSession();

  const event = make('event');
  const shirt = make('shirt', 'withPurchases');

  // Specify the other units that are required for this test.
  // needs: ['service:foo']
});

test('it fires "didResize"  when the window is resized', function(assert) {

  const service = this.subject({
    heightSensitive: true,
    widthSensitive: false,
  });
  let didResizeCallCount = 0;
  service.on('didResize', () => {
    didResizeCallCount++;
  });

  const evt = new Event('resize');

  window.dispatchEvent(evt);
  assert.equal(didResizeCallCount, 0, 'didResize called 0 time on event firing');
  service.incrementProperty('_oldHeight', -20);
  window.dispatchEvent(evt);
  assert.equal(didResizeCallCount, 1, 'didResize called 1 time on event firing');
  service.set('heightSensitive', false);
  service.incrementProperty('_oldHeight', -20);
  window.dispatchEvent(evt);
  assert.equal(didResizeCallCount, 1, 'didResize shouldn\'t be called again if heightSensitive is false');

});

test('screenHeight is bound to the non debounced resize', function(assert) {

  const service = this.subject({

    // custom url mock
    Ember.$.mockjax({ url, responseText: payload, type: 'GET' });
    Ember.$.mockjax({ url: 'https://checkout.stripe.com/api/outer/manhattan?key=a', responseText: {}, type: 'GET' });
  }
}


test('a registration is visible', withChai(async expect => {
  authenticateSession();

  // ember-data mocks
  const event = make('event', { isEvent: true });
  const order = make('order', { paid: false, total: 50, orderLineItems: [] });
  const registrations = makeList('users/registration', 1, { attendeeFirstName: 'First', attendeeLastName: 'Last', orders: [order], unpaidOrder: order });

  const rootRegistrationUrl = `${event.get('domain')}/register/${event.get('id')}`;
  mockRequests({ event, registrations, order });

  await visit(rootRegistrationUrl);
  expect(currentRouteName()).to.eq('register.event-registration.index');

  const text = find('td').text()

  expect(text).to.include('First Last')
}));

test('no items - are incomplete', withChai(async expect => {
  authenticateSession();

  // ember-data mocks
  const event = make('event', { isEvent: true });
  const order = make('order', { paid: false, total: 50, orderLineItems: [] });

// if you don't have a custom resolver, do it like this:
setResolver(Ember.DefaultResolver.create());

test('it renders', function(assert) {
    assert.expect(2);

    // setup the outer context
    this.set('value', 'cat');
    this.on('action', function(result) {
        assert.equal(result, 'bar', 'The correct result was returned');
        assert.equal(this.get('value'), 'cat');
    });

    // render the component
    this.render(hbs`
        {{ x-foo value=value action="result" }}
    `);
    this.render('{{ x-foo value=value action="result" }}');
    this.render([
        '{{ x-foo value=value action="result" }}'
    ]);

    assert.equal(this.$('div>.value').text(), 'cat', 'The component shows the correct value');

    this.$('button').click();
});

test('it renders', function(assert) {
    assert.expect(1);

  beforeEach() { mockSetup({ logLevel: 1, mockjaxLogLevel: 4 }); },
  afterEach() { mockTeardown(); }
});

test('can navigate from upcoming events', withChai(async expect => {
  const upcomingEvents = makeList('upcoming-event', 2);
  const openingTier = make('pricing-tier', { date: new Date(2016, 7) });
  const event = make('event', { openingTier });

  mockFindAll('upcoming-event').returns({ models: upcomingEvents });
  mockFindRecord('event').returns({ model: event });

  const url = `/api/hosts/${event.get('domain')}`;
  const payload = { data: { type: 'events', id: 1, attributes: { id: 1, name: event.get('name') } } };

  Ember.$.mockjax({ url, responseText: payload, type: 'GET' });

  await visit('/upcoming-events');

  const upcomingEvent = upcomingEvents.get(0);
  const linkSelector = `[data-test-upcoming-event-id="${upcomingEvent.id}"] a`;
  const link = find(linkSelector);
  const text = link.text();

  expect(text).to.include(upcomingEvent.get('name'));

  await click(linkSelector);

  expect(currentRouteName()).to.equal('register.event-registration.must-login');
}));

    'model:line-item',
    'model:shirt',
    'model:custom-field',
    'model:sponsorship',
    'model:registration',
    'model:integration'
  ],

  beforeEach() {
    manualSetup(this.container);
  }
});

test('#registrationIsOpen is true once registrationOpensAt is in the past', function(assert) {
  const openingTier = make('opening-tier');
  const event = make('event', { openingTier });

  Ember.run(() => event.set('registrationOpensAt', moment().subtract(1, 'days').toDate()));

  assert.ok(event.get('registrationIsOpen'))
});

test('#registrationIsOpen is false if registrationOpensAt is in the future', function(assert) {
  const openingTier = make('opening-tier');
  const event = make('event', { openingTier });

  Ember.run(() => event.set('registrationOpensAt', moment().add(1, 'days').toDate()));

  assert.notOk(event.get('registrationIsOpen'))
});