alephant-preview 0.5.3 → 0.6.0

data/spec/fixtures/components/bar/mapper.rb

@@ -1,7 +1,7 @@
 class BarMapper < Alephant::Publisher::Request::DataMapper
   def data
     {
-      :bar => "data mapped content"
+      bar: 'data mapped content'
     }
   end
 end

data/spec/fixtures/components/bar/models/bar.rb

@@ -1,4 +1,4 @@
-require "alephant/renderer/views/html"
+require 'alephant/renderer/views/html'
 
 module MyApp
   class Bar < ::Alephant::Renderer::Views::Html

data/spec/fixtures/components/baz/mapper.rb

@@ -1,11 +1,11 @@
-require "json"
+require 'json'
 
 class BazMapper < Alephant::Publisher::Request::DataMapper
   def data
     (1..3).reduce({}) do |accum, _index|
       accum.merge(
         JSON.parse(
-          get("/test/call").body
+          get('/test/call').body
         )
       )
     end

data/spec/fixtures/components/baz/models/baz.rb

@@ -1,4 +1,4 @@
-require "alephant/renderer/views/html"
+require 'alephant/renderer/views/html'
 
 module MyApp
   class Baz < ::Alephant::Renderer::Views::Html

data/spec/fixtures/components/foo/models/foo.rb

@@ -1,9 +1,9 @@
-require "alephant/renderer/views/json"
+require 'alephant/renderer/views/json'
 
 module MyApp
   class Foo < ::Alephant::Renderer::Views::Json
     def to_h
-      { "content" => "as json" }
+      { 'content' => 'as json' }
     end
   end
 end

data/spec/integration/preview_spec.rb

@@ -1,45 +1,45 @@
-require "spec_helper"
+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"
+  describe 'preview endpoint (GET /preview/{id}/{template}/{region}/{fixture})' do
+    describe 'content' do
+      expected_time = '123456789'
 
-      context "with valid data" do
+      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 (:id) { 'foo' }
         let (:template) { id }
         let (:fixture) { id }
-        let (:region) { "page_region" }
+        let (:region) { 'page_region' }
 
-        it "should return correct response" do
+        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"
+          'Content-Type'                => 'application/json',
+          'Access-Control-Allow-Origin' => '*',
+          'X-Sequence'                  => expected_time,
+          'Content-Length'              => '31'
         }
 
-        it "should have correct response headers" do
+        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"
+  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)
@@ -48,66 +48,66 @@ describe Alephant::Preview::Server do
       end
       let (:response) { last_response.body.chomp }
 
-      context "without a data mapper" do
-        let (:id) { "foo" }
+      context 'without a data mapper' do
+        let (:id) { 'foo' }
         let (:template) { id }
         let (:fixture) { id }
 
-        it "should return correct response" do
+        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"
+          'Content-Type'                => 'application/json',
+          'Access-Control-Allow-Origin' => '*',
+          'X-Sequence'                  => expected_time,
+          'Content-Length'              => '21'
         }
 
-        it "should have correct response headers" do
+        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" }
+      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")
+          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"
+            'Content-Type'                => 'text/html',
+            'Access-Control-Allow-Origin' => '*',
+            'X-Sequence'                  => expected_time,
+            'Content-Length'              => '20'
           }
 
-          it "should have correct response headers" do
+          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" }
+        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")
+          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"
+            'Content-Type'                => 'text/html',
+            'Access-Control-Allow-Origin' => '*',
+            'X-Sequence'                  => expected_time,
+            'Content-Length'              => '38'
           }
 
-          it "should have correct response headers" do
+          it 'should have correct response headers' do
             expect(last_response.headers).to include(expected_headers)
           end
         end
@@ -116,8 +116,8 @@ describe Alephant::Preview::Server do
   end
 
   describe 'component batch endpoint (GET /components/batch?components[#{id}]=#{id})' do
-    describe "content" do
-      expected_time = "123456789"
+    describe 'content' do
+      expected_time = '123456789'
 
       before(:each) do
         allow(Time).to receive(:now).and_return(expected_time)
@@ -125,74 +125,74 @@ describe Alephant::Preview::Server do
         get "/components/batch?components[#{id}][component]=#{id}&components[#{id}][options][fixture]=#{id}"
       end
 
-      let (:response) { JSON.parse(last_response.body.chomp, :symbolize_names => true) }
+      let (:response) { JSON.parse(last_response.body.chomp, symbolize_names: true) }
 
-      context "without a data mapper" do
-        let (:id) { "foo" }
+      context 'without a data mapper' do
+        let (:id) { 'foo' }
         let (:template) { id }
         let (:fixture) { id }
 
         expected = {
-          :components => [
+          components: [
             {
-              :component    => "foo",
-              :options      => {},
-              :status       => 200,
-              :body         => %({"content":"as json"}),
-              :content_type => "application/json",
-              :sequence_id  => expected_time
+              component:    'foo',
+              options:      {},
+              status:       200,
+              body:         %({"content":"as json"}),
+              content_type: 'application/json',
+              sequence_id:  expected_time
             }
           ]
         }
 
-        it "should return correct response" do
+        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" }
+      context 'with a data mapper' do
+        context 'using a single fixture' do
+          let (:id) { 'bar' }
           let (:template) { id }
           let (:fixture) { id }
 
           expected = {
-            :components => [
+            components: [
               {
-                :component    => "bar",
-                :options      => {},
-                :status       => 200,
-                :body         => "data mapped content\n",
-                :content_type => "text/html",
-                :sequence_id  => expected_time
+                component:    'bar',
+                options:      {},
+                status:       200,
+                body:         "data mapped content\n",
+                content_type: 'text/html',
+                sequence_id:  expected_time
               }
             ]
           }
 
-          it "should return correct response" do
+          it 'should return correct response' do
             expect(response).to eq(expected)
           end
         end
 
-        context "using multiple fixtures" do
-          let (:id) { "baz" }
+        context 'using multiple fixtures' do
+          let (:id) { 'baz' }
           let (:template) { id }
           let (:fixture) { id }
 
           expected = {
-            :components => [
+            components: [
               {
-                :component    => "baz",
-                :options      => {},
-                :status       => 200,
-                :body         => "multiple endpoint data mapped content\n",
-                :content_type => "text/html",
-                :sequence_id  => expected_time
+                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
+          it 'should return correct response' do
             expect(response).to eq(expected)
           end
         end
@@ -200,87 +200,87 @@ describe Alephant::Preview::Server do
     end
   end
 
-  describe "component batch endpoint (POST /components/batch" do
-    describe "content" do
-      expected_time = "123456789"
+  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 => [
+        post '/components/batch', {
+          components: [
             {
-              :component => id,
-              :options   => {
-                :fixture => id
+              component: id,
+              options:   {
+                fixture: id
               }
             }
           ]
         }.to_json
       end
 
-      let (:response) { JSON.parse(last_response.body.chomp, :symbolize_names => true) }
+      let (:response) { JSON.parse(last_response.body.chomp, symbolize_names: true) }
 
-      context "without a data mapper" do
-        let(:id) { "foo" }
+      context 'without a data mapper' do
+        let(:id) { 'foo' }
 
         expected = {
-          :components => [
+          components: [
             {
-              :component    => "foo",
-              :options      => {},
-              :status       => 200,
-              :body         => %({"content":"as json"}),
-              :content_type => "application/json",
-              :sequence_id  => expected_time
+              component:    'foo',
+              options:      {},
+              status:       200,
+              body:         %({"content":"as json"}),
+              content_type: 'application/json',
+              sequence_id:  expected_time
             }
           ]
         }
 
-        it "should return correct response" do
+        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" }
+      context 'with a data mapper' do
+        context 'using a single fixture' do
+          let (:id) { 'bar' }
 
           expected = {
-            :components => [
+            components: [
               {
-                :component    => "bar",
-                :options      => {},
-                :status       => 200,
-                :body         => "data mapped content\n",
-                :content_type => "text/html",
-                :sequence_id  => expected_time
+                component:    'bar',
+                options:      {},
+                status:       200,
+                body:         "data mapped content\n",
+                content_type: 'text/html',
+                sequence_id:  expected_time
               }
             ]
           }
 
-          it "should return correct response" do
+          it 'should return correct response' do
             expect(response).to eq(expected)
           end
         end
 
-        context "using multiple fixtures" do
-          let (:id) { "baz" }
+        context 'using multiple fixtures' do
+          let (:id) { 'baz' }
 
           expected = {
-            :components => [
+            components: [
               {
-                :component    => "baz",
-                :options      => {},
-                :status       => 200,
-                :body         => "multiple endpoint data mapped content\n",
-                :content_type => "text/html",
-                :sequence_id  => expected_time
+                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
+          it 'should return correct response' do
             expect(response).to eq(expected)
           end
         end
@@ -288,13 +288,13 @@ describe Alephant::Preview::Server do
     end
   end
 
-  describe "status endpoint (GET /status)" do
+  describe 'status endpoint (GET /status)' do
     before(:each) do
-      get "/status"
+      get '/status'
     end
 
-    context "status code" do
-      it "should return ok status code" do
+    context 'status code' do
+      it 'should return ok status code' do
         expect(last_response.status).to eq(200)
       end
     end