ninetails 0.0.2 → 0.1.0

data/spec/factories/page_sections.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+
+  factory :document_head_section, class: Ninetails::PageSection do
+    type "DocumentHead"
+    tags Section::DocumentHead.new.tags
+    elements Section::DocumentHead.new.serialize_elements
+  end
+
+  factory :billboard_section, class: Ninetails::PageSection do
+    type "Billboard"
+    tags Section::Billboard.new.tags
+    elements Section::Billboard.new.serialize_elements
+  end
+
+end

data/spec/models/{section_spec.rb → page_section_spec.rb}

@@ -1,7 +1,7 @@
 require 'rails_helper'
 
-module SectionTemplate
-  class TestSection < Ninetails::SectionTemplate
+module Section
+  class TestSection < Ninetails::Section
     located_in :body
     has_element :headline, Element::Text
     has_element :button, Element::Button
@@ -9,7 +9,7 @@ module SectionTemplate
   end
 end
 
-RSpec.describe Ninetails::Section, type: :model do
+RSpec.describe Ninetails::PageSection, type: :model do
 
   describe "deserializing a json blob" do
     let(:headline) { "Hello world!" }
@@ -48,42 +48,42 @@ RSpec.describe Ninetails::Section, type: :model do
       }
     end
 
-    let(:section) { Ninetails::Section.new(json) }
+    let(:section) { Ninetails::PageSection.new(json) }
 
-    it "should create a SectionTemplate instance" do
+    it "should create a Section instance" do
       section.deserialize
-      expect(section.template).to be_a SectionTemplate::TestSection
+      expect(section.section).to be_a Section::TestSection
     end
 
     it "should have an array of elements_instances" do
       section.deserialize
-      expect(section.template.elements_instances.size).to eq 3
+      expect(section.section.elements_instances.size).to eq 3
     end
 
     it "should include an element for 'text', 'button', and 'link'" do
       section.deserialize
-      expect(section.template.elements_instances[0].name).to eq :headline
-      expect(section.template.elements_instances[1].name).to eq :button
-      expect(section.template.elements_instances[2].name).to eq :messages
+      expect(section.section.elements_instances[0].name).to eq :headline
+      expect(section.section.elements_instances[1].name).to eq :button
+      expect(section.section.elements_instances[2].name).to eq :messages
     end
 
     it "should be the correct type for 'text', 'button', and 'link'" do
       section.deserialize
-      expect(section.template.elements_instances[0].type).to eq Element::Text
-      expect(section.template.elements_instances[1].type).to eq Element::Button
-      expect(section.template.elements_instances[2].type).to eq Element::Text
+      expect(section.section.elements_instances[0].type).to eq Element::Text
+      expect(section.section.elements_instances[1].type).to eq Element::Button
+      expect(section.section.elements_instances[2].type).to eq Element::Text
     end
 
     it "should call deserialize on each element" do
-      expect(SectionTemplate::TestSection.find_element("headline")).to receive(:deserialize).with(json["elements"]["headline"])
-      expect(SectionTemplate::TestSection.find_element("button")).to receive(:deserialize).with(json["elements"]["button"])
-      expect(SectionTemplate::TestSection.find_element("messages")).to receive(:deserialize).with(json["elements"]["messages"])
+      expect(Section::TestSection.find_element("headline")).to receive(:deserialize).with(json["elements"]["headline"])
+      expect(Section::TestSection.find_element("button")).to receive(:deserialize).with(json["elements"]["button"])
+      expect(Section::TestSection.find_element("messages")).to receive(:deserialize).with(json["elements"]["messages"])
       section.deserialize
     end
 
     it "should be possible to reserialize into json" do
       section.deserialize
-      serialized = section.template.serialize.with_indifferent_access
+      serialized = section.section.serialize.with_indifferent_access
       expect(serialized[:elements][:headline][:content][:text]).to eq headline
       expect(serialized[:elements][:messages][0][:content][:text]).to eq first_message
       expect(serialized[:elements][:messages][1][:content][:text]).to eq second_message
@@ -91,23 +91,4 @@ RSpec.describe Ninetails::Section, type: :model do
 
   end
 
-  describe "building json" do
-
-    let(:section) { build :document_head_section }
-    let(:json) do
-      {
-        id: section.id,
-        name: section.name,
-        type: section.type,
-        tags: section.tags,
-        elements: section.elements
-      }.to_json
-    end
-
-    it "should build the section into json" do
-      expect(section.to_builder.target!).to eq json
-    end
-
-  end
-
 end

data/spec/models/page_spec.rb

@@ -2,23 +2,18 @@ require 'rails_helper'
 
 RSpec.describe Ninetails::Page, type: :model do
 
-  describe "building json" do
+  describe "validations" do
 
-    let(:page) { create :page }
-    let(:json) do
-      {
-        page: {
-          id: page.id,
-          name: page.name,
-          url: page.url,
-          revisionId: page.revision.id,
-          sections: page.sections_to_builder
-        }
-      }.to_json
+    it "should require a url" do
+      new_page = Ninetails::Page.new url: nil
+      expect(new_page.valid?).to be false
+      expect(new_page.errors[:url]).to eq ["can't be blank"]
     end
 
-    it "should build the page into json" do
-      expect(page.to_builder.target!).to eq json
+    it "should require a unique url" do
+      new_page = Ninetails::Page.new url: create(:page).url
+      expect(new_page.valid?).to be false
+      expect(new_page.errors[:url]).to eq ["has already been taken"]
     end
 
   end

data/spec/requests/middleware_spec.rb

@@ -0,0 +1,80 @@
+require "rails_helper"
+
+module Ninetails
+  class TestController < ApplicationController
+    def index
+      render json: {
+        foo_bar: "baz_box",
+        hello_world: {
+          this_is_dog_fort: "Checking in"
+        }
+      }
+    end
+
+    def show
+      render text: "foo_bar"
+    end
+  end
+end
+
+class DummyController < ActionController::Base
+  def index
+    render json: {
+      this_is_a_key: "thanks"
+    }
+  end
+end
+
+describe "Key conversion middleware" do
+
+  # Add the Ninetails::TestController and DummyController stuff to routes
+  before do
+    Ninetails::Engine.routes.send(:eval_block, -> {
+      get "/test", to: "test#index"
+      get "/test/foo", to: "test#show"
+    })
+
+    Dummy::Application.routes.send(:eval_block, -> {
+      get "/dummy", to: "dummy#index"
+    })
+  end
+
+  describe "when Ninetails::Config.key_style is camelcase" do
+    before do
+      Ninetails::Config.key_style = :camelcase
+    end
+
+    it "should convert all keys to camelcase" do
+      get "/test"
+      expect(json).to have_key "fooBar"
+      expect(json["helloWorld"]).to have_key "thisIsDogFort"
+    end
+
+    it "should not modify non-json responses" do
+      get "/test/foo"
+      expect(response.body).to eq "foo_bar"
+    end
+
+    it "should not modify responses from outside of the Ninetails engine" do
+      get "/dummy"
+      expect(json).to have_key "this_is_a_key"
+    end
+  end
+
+  describe "when Ninetails::Config.key_style is underscore" do
+    before do
+      Ninetails::Config.key_style = :underscore
+    end
+
+    it "should not modify any response from Ninetails" do
+      get "/test"
+      expect(json).to have_key "foo_bar"
+    end
+
+    it "should not modify any response from the parent app" do
+      get "/dummy"
+      expect(json).to have_key "this_is_a_key"
+    end
+  end
+
+end

data/spec/requests/page_revisions_spec.rb

@@ -25,27 +25,7 @@ describe "Page Revisions API" do
         "page_revision": {
           "message": "",
           "sections":[
-            {
-              "name": "",
-              "type": "DocumentHead",
-              "tags": {
-                "position": "head"
-              },
-              "elements": {
-                "title": {
-                  "type": "Text",
-                  "content": {
-                    "text": "iZettle – Accept credit card payments with your iPhone, iPad or Android"
-                  }
-                },
-                "description": {
-                  "type": "Meta",
-                  "content": {
-                    "text": "Accept credit card payments on the go with iZettle. All you need is a smartphone or a tablet and our free app."
-                  }
-                }
-              }
-            }
+            document_head_section
           ]
         }
       }
@@ -56,27 +36,7 @@ describe "Page Revisions API" do
         "page_revision": {
           "message": "",
           "sections":[
-            {
-              "name": "",
-              "type": "DocumentHead",
-              "tags": {
-                "position": "head"
-              },
-              "elements": {
-                "title": {
-                  "type": "Text",
-                  "content": {
-                    "text": ""
-                  }
-                },
-                "description": {
-                  "type": "Meta",
-                  "content": {
-                    "text": ""
-                  }
-                }
-              }
-            }
+            document_head_section(title: "", description: "")
           ]
         }
       }
@@ -114,4 +74,43 @@ describe "Page Revisions API" do
     end
   end
 
+  describe "handling hash keys in camelcase" do
+
+    let(:camelcased_revision) do
+      {
+        page_revision: {
+          message: "",
+          sections: [
+            {
+              "name": "",
+              "type": "MinimalBillboard",
+              "tags": {
+                "position": "body"
+              },
+              "elements": {
+                "backgroundImage": {
+                  "type": "Figure",
+                  "image": {
+                    "src": "/foobar.jpg",
+                    "alt": "Hello world"
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    end
+
+    it "should not cause problems" do
+      expect {
+        post "/pages/#{page.id}/revisions", camelcased_revision
+      }.to change { page.revisions.count }.by(1)
+
+      expect(response).to be_success
+      expect(json["page"]["revisionId"]).to_not be_nil
+    end
+
+  end
+
 end

data/spec/requests/pages_spec.rb

@@ -5,13 +5,66 @@ describe "Pages API" do
   let(:page) { create :page }
   let(:page_url) { "/pages/#{CGI.escape(page.url)}" }
 
+  describe "listing pages" do
+    before do
+      create_list :page, 5
+    end
+
+    it "should return the correct number of pages" do
+      get "/pages"
+      expect(response).to be_success
+      expect(json["pages"].size).to eq Ninetails::Page.count
+    end
+
+    it "should include the id and url for each page" do
+      get "/pages"
+
+      json["pages"].each do |page|
+        expect(page).to have_key "id"
+        expect(page).to have_key "url"
+      end
+    end
+  end
+
+  describe "creating a page" do
+
+    let(:valid_page_params) do
+      {
+        page: {
+          url: "/foobar"
+        }
+      }
+    end
+
+    let(:existing_page_url_params) do
+      {
+        page: {
+          url: page.url
+        }
+      }
+    end
+
+    it "should save the page if it is valid" do
+      expect {
+        post "/pages", valid_page_params
+      }.to change{ Ninetails::Page.count }.by(1)
+    end
+
+    it "should show errors if the url is taken" do
+      post "/pages", existing_page_url_params
+
+      expect(response).to_not be_success
+      expect(json["page"]["errors"]["url"]).not_to be_empty
+    end
+
+  end
+
   describe "when not specifying revision" do
     describe "when the page exists" do
       it "should return the current revision of a page" do
         get page_url
 
         expect(response).to be_success
-        expect(response.body).to eq page.to_builder.target!
         expect(json["page"]["revisionId"]).to eq page.current_revision.id
       end
     end

data/spec/requests/sections_spec.rb

@@ -0,0 +1,32 @@
+require 'rails_helper'
+
+describe "Sections API" do
+
+  it "should list the available sections" do
+    get "/sections"
+    expect(response).to be_success
+    billboard_json = json["sections"].find { |s| s["type"] == "Billboard" }.to_json
+    expect(billboard_json).to eq Section::Billboard.new.serialize.to_json
+  end
+
+  it "should be possible to get a section's structure" do
+    get "/sections/Billboard"
+    expect(response).to be_success
+    expect(response.body).to eq Section::Billboard.new.serialize.to_json
+  end
+
+  describe "validating" do
+    it "should return no errors when the section is valid" do
+      post "/sections/validate", section: document_head_section
+      expect(response).to be_success
+      expect(json["section"]["elements"]["title"]["content"]).not_to have_key "errors"
+    end
+
+    it "should return errors when the section is invalid" do
+      post "/sections/validate", section: document_head_section(title: "")
+      expect(response).not_to be_success
+      expect(json["section"]["elements"]["title"]["content"]).to have_key "errors"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 ENV["RAILS_ENV"] = "test"
 
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
 
 # This file was generated by the `rails generate rspec:install` command. Conventionally, all
@@ -95,4 +98,5 @@ RSpec.configure do |config|
 =end
 
   config.include Requests::JsonHelpers, type: :request
+  config.include SectionHelpers
 end

data/spec/support/section_helpers.rb

@@ -0,0 +1,27 @@
+module SectionHelpers
+
+  def document_head_section(title: "Title text", description: "Description text")
+    {
+      "name": "",
+      "type": "DocumentHead",
+      "tags": {
+        "position": "head"
+      },
+      "elements": {
+        "title": {
+          "type": "Text",
+          "content": {
+            "text": title
+          }
+        },
+        "description": {
+          "type": "Meta",
+          "content": {
+            "text": description
+          }
+        }
+      }
+    }
+  end
+
+end