require 'spec_helper'

describe Alephant::Preview::Server do
  include Rack::Test::Methods
  let (:app) { subject }

  describe 'preview endpoint (GET /preview/{id}/{template}/{region}/{fixture})' do
    describe 'content' do
      expected_time = '123456789'

      context 'with valid data' do
        before(:each) do
          allow(Time).to receive(:now).and_return(expected_time)

          get "/preview/#{id}/#{template}/#{region}/#{fixture}"
        end
        let (:id) { 'foo' }
        let (:template) { id }
        let (:fixture) { id }
        let (:region) { 'page_region' }

        it 'should return correct response' do
          expect(last_response.body).to eq(%(top{"content":"as json"}bottom\n))
        end

        expected_headers = {
          'Content-Type'                => 'application/json',
          'Access-Control-Allow-Origin' => '*',
          'X-Sequence'                  => expected_time,
          'Content-Length'              => '31'
        }

        it 'should have correct response headers' do
          expect(last_response.headers).to include(expected_headers)
        end
      end
    end
  end

  describe 'component endpoint (GET /component/{id}/{template}/{fixture})' do
    describe 'content' do
      expected_time = '123456789'

      before(:each) do
        allow(Time).to receive(:now).and_return(expected_time)

        get "/component/#{id}/#{template}/#{fixture}"
      end
      let (:response) { last_response.body.chomp }

      context 'without a data mapper' do
        let (:id) { 'foo' }
        let (:template) { id }
        let (:fixture) { id }

        it 'should return correct response' do
          expect(response).to eq(%({"content":"as json"}))
        end

        expected_headers = {
          'Content-Type'                => 'application/json',
          'Access-Control-Allow-Origin' => '*',
          'X-Sequence'                  => expected_time,
          'Content-Length'              => '21'
        }

        it 'should have correct response headers' do
          expect(last_response.headers).to include(expected_headers)
        end
      end

      context 'with a data mapper' do
        context 'using a single fixture' do
          let (:id) { 'bar' }
          let (:template) { id }
          let (:fixture) { id }

          it 'should return data mapped content' do
            expect(response).to eq('data mapped content')
          end

          expected_headers = {
            'Content-Type'                => 'text/html',
            'Access-Control-Allow-Origin' => '*',
            'X-Sequence'                  => expected_time,
            'Content-Length'              => '20'
          }

          it 'should have correct response headers' do
            expect(last_response.headers).to include(expected_headers)
          end
        end

        context 'using multiple fixtures' do
          let (:id) { 'baz' }
          let (:template) { id }
          let (:fixture) { id }

          it 'should return multiple mapped content' do
            expect(response).to eq('multiple endpoint data mapped content')
          end

          expected_headers = {
            'Content-Type'                => 'text/html',
            'Access-Control-Allow-Origin' => '*',
            'X-Sequence'                  => expected_time,
            'Content-Length'              => '38'
          }

          it 'should have correct response headers' do
            expect(last_response.headers).to include(expected_headers)
          end
        end
      end
    end
  end

  describe 'component batch endpoint (GET /components/batch?components[#{id}]=#{id})' do
    describe 'content' do
      expected_time = '123456789'

      before(:each) do
        allow(Time).to receive(:now).and_return(expected_time)

        get "/components/batch?components[#{id}][component]=#{id}&components[#{id}][options][fixture]=#{id}"
      end

      let (:response) { JSON.parse(last_response.body.chomp, symbolize_names: true) }

      context 'without a data mapper' do
        let (:id) { 'foo' }
        let (:template) { id }
        let (:fixture) { id }

        expected = {
          components: [
            {
              component:    'foo',
              options:      {},
              status:       200,
              body:         %({"content":"as json"}),
              content_type: 'application/json',
              sequence_id:  expected_time
            }
          ]
        }

        it 'should return correct response' do
          expect(response).to eq(expected)
        end
      end

      context 'with a data mapper' do
        context 'using a single fixture' do
          let (:id) { 'bar' }
          let (:template) { id }
          let (:fixture) { id }

          expected = {
            components: [
              {
                component:    'bar',
                options:      {},
                status:       200,
                body:         "data mapped content\n",
                content_type: 'text/html',
                sequence_id:  expected_time
              }
            ]
          }

          it 'should return correct response' do
            expect(response).to eq(expected)
          end
        end

        context 'using multiple fixtures' do
          let (:id) { 'baz' }
          let (:template) { id }
          let (:fixture) { id }

          expected = {
            components: [
              {
                component:    'baz',
                options:      {},
                status:       200,
                body:         "multiple endpoint data mapped content\n",
                content_type: 'text/html',
                sequence_id:  expected_time
              }
            ]
          }

          it 'should return correct response' do
            expect(response).to eq(expected)
          end
        end
      end
    end
  end

  describe 'component batch endpoint (POST /components/batch' do
    describe 'content' do
      expected_time = '123456789'

      before(:each) do
        allow(Time).to receive(:now).and_return(expected_time)

        post '/components/batch', {
          components: [
            {
              component: id,
              options:   {
                fixture: id
              }
            }
          ]
        }.to_json
      end

      let (:response) { JSON.parse(last_response.body.chomp, symbolize_names: true) }

      context 'without a data mapper' do
        let(:id) { 'foo' }

        expected = {
          components: [
            {
              component:    'foo',
              options:      {},
              status:       200,
              body:         %({"content":"as json"}),
              content_type: 'application/json',
              sequence_id:  expected_time
            }
          ]
        }

        it 'should return correct response' do
          expect(response).to eq(expected)
        end
      end

      context 'with a data mapper' do
        context 'using a single fixture' do
          let (:id) { 'bar' }

          expected = {
            components: [
              {
                component:    'bar',
                options:      {},
                status:       200,
                body:         "data mapped content\n",
                content_type: 'text/html',
                sequence_id:  expected_time
              }
            ]
          }

          it 'should return correct response' do
            expect(response).to eq(expected)
          end
        end

        context 'using multiple fixtures' do
          let (:id) { 'baz' }

          expected = {
            components: [
              {
                component:    'baz',
                options:      {},
                status:       200,
                body:         "multiple endpoint data mapped content\n",
                content_type: 'text/html',
                sequence_id:  expected_time
              }
            ]
          }

          it 'should return correct response' do
            expect(response).to eq(expected)
          end
        end
      end
    end
  end

  describe 'status endpoint (GET /status)' do
    before(:each) do
      get '/status'
    end

    context 'status code' do
      it 'should return ok status code' do
        expect(last_response.status).to eq(200)
      end
    end
  end
end