knitkit 2.0.0 → 2.0.1

data/spec/models/attribute_type_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe AttributeType do
+  it "can be instantiated" do
+    AttributeType.new.should be_an_instance_of(AttributeType)
+  end
+
+  it "can be saved successfully" do
+    new_attribute_type = AttributeType.create(:description => "Some description")
+    new_attribute_type.should be_persisted
+    new_attribute_type.internal_identifier.should eq("some_description")
+
+  end
+
+  describe "values_by_date_range" do
+    it "should return all values attatched to AttributeType for the given date range" do
+      attribute_type = AttributeType.new
+      attribute_type.data_type = 'Date'
+      attribute_type.description = 'Some Date Attribute'
+      attribute_type.save
+
+      in_range_value = AttributeValue.new
+      in_range_value.value = "2011-12-15 00:00:00"
+      attribute_type.attribute_values << in_range_value
+      in_range_value.save
+
+      out_of_range_value = AttributeValue.new
+      out_of_range_value.value = "2011-12-31 00:00:00"
+      attribute_type.attribute_values << out_of_range_value
+      out_of_range_value.save
+      
+      start_date = Date.civil(2011, 12, 1)
+      end_date = Date.civil(2011, 12, 30)
+
+      date_range_values = attribute_type.values_by_date_range(start_date, end_date)
+
+      date_range_values.should include(in_range_value)
+    end
+  end
+
+  describe "find_by_iid_with_description" do
+    it "should return an AttributeType object with the given description" do
+      attribute_type = AttributeType.create(:description => "Some Description")
+      found_attribute_type = AttributeType.find_by_iid_with_description("some description")
+      found_attribute_type.should eq(attribute_type)
+    end
+  end
+
+  describe "update_iid" do
+    it "should set the iid to a snake case version of the description when a new attribute type is created" do
+      attribute_type = AttributeType.create(:description => " Some attribute type ", :data_type => "text")
+      attribute_type.internal_identifier.should eq("some_attribute_type")
+    end
+  end
+end

data/spec/models/attribute_value_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe AttributeValue do
+  it "can be instantiated" do
+    AttributeValue.new.should be_an_instance_of(AttributeValue)
+  end
+
+  it "can be saved successfully" do
+    attribute_type = AttributeType.create(:description => "Some Desc", :data_type => "Text")
+    attribute_value = AttributeValue.new
+    attribute_type.attribute_values << attribute_value
+    attribute_value.save
+
+    attribute_value.should be_persisted
+  end
+
+  it "should destroy attatched AttributeType when a value is deleted if that is the last value connected to the AttributeType" do
+    attribute_type = AttributeType.create(:description => "Some Desc", :data_type => "Text")
+    attribute_value = AttributeValue.new
+    attribute_type.attribute_values << attribute_value
+    attribute_value.save
+
+    AttributeType.find_by_description("Some Desc").should eq(attribute_type)
+    attribute_value.destroy
+    AttributeType.find_by_description("Some Desc").should eq(nil)
+  end
+
+  describe "is_date?" do
+    it "should return true if the AttributeValue's AttributeType has a data_type of 'Date'" do
+      attribute_type = AttributeType.create(:description => "Some Date Attribute", :data_type => "Date")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "12/12/2011"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.is_date?.should eq(true)
+    end
+
+    it "should return false if the AttributeValue's AttributeType has a data_type not equal to 'Date'" do
+      attribute_type = AttributeType.create(:description => "Some Text Attribute", :data_type => "Text")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "some text"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.is_date?.should eq(false)
+    end
+  end
+
+  describe "value_as_date" do
+    it "should return a date object equivilant to the AttributeValue's value" do
+      attribute_type = AttributeType.create(:description => "Some Date Attribute", :data_type => "Date")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "2011-12-01 00:00:00"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      date = Date.civil(2011, 12, 1)
+      attribute_value.value_as_date.should eq(date)
+    end
+  end
+
+  describe "value_as_data_type" do
+    it "should return a date if the associated attribute_types data_type is 'Date'" do
+      attribute_type = AttributeType.create(:description => "Some Date Attribute", :data_type => "Date")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "2011-12-01 00:00:00"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.value_as_data_type.should be_kind_of(Date)
+    end
+
+    it "should return a string if the associated attribute_types data_type is 'String'" do
+      attribute_type = AttributeType.create(:description => "Some String Attribute", :data_type => "String")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "some string"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.value_as_data_type.should be_kind_of(String)
+    end
+
+    it "should return a boolean if the associated attribute_types data_type is 'Boolean'" do
+      attribute_type = AttributeType.create(:description => "Some Boolean Attribute", :data_type => "Boolean")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "true"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.value_as_data_type.should eq(true)
+    end
+
+    it "should return a integer if the associated attribute_types data_type is 'Int'" do
+      attribute_type = AttributeType.create(:description => "Some Integer Attribute", :data_type => "Int")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "1"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.value_as_data_type.should be_kind_of(Integer)
+    end
+
+    it "should return a float if the associated attribute_types data_type is 'Float'" do
+      attribute_type = AttributeType.create(:description => "Some Float Attribute", :data_type => "Float")
+      attribute_value = AttributeValue.new
+      attribute_value.value = "1.1"
+      attribute_type.attribute_values << attribute_value
+      attribute_value.save
+
+      attribute_value.value_as_data_type.should be_kind_of(Float)
+    end
+  end
+end

data/spec/models/blog_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Blog do
+  it "can be instantiated" do
+    Blog.new.should be_an_instance_of(Blog)
+  end
+
+  it "can be saved successfully" do
+    Blog.create(:title => "Some Title").should be_persisted
+  end
+  
+  it "can find_blog_post" do
+    blog = Blog.create(:title => "some title")
+    blog.find_blog_post('test')
+  end
+end

data/spec/models/comment_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Comment do
+  it "can be instantiated" do
+    Comment.new.should be_an_instance_of(Comment)
+  end
+
+  it "can be saved successfully" do
+    Comment.create(:comment => "Test Comment").should be_persisted
+  end
+end

data/spec/models/content_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe Content do
+  it "can be instantiated" do
+    Content.new.should be_an_instance_of(Content)
+  end
+
+  #it "can be saved successfully" do
+  #  Content.create(:type => 'Page', :title => 'Test').should be_persisted
+  #end
+
+  describe "self.find_by_section_id" do
+    it "should return all articles belonging to the given section" do
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article")
+
+      website_section = WebsiteSection.create(:title => "section title")
+      article.website_sections << website_section
+
+      results = Content.find_by_section_id(1)
+      results.should include(article)
+    end
+  end
+
+  describe "self.find_by_section_id_filtered_by_id" do
+    it "should return all articles conected to the given section that also have ids in the given filter list" do
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article")
+      article2 = Article.create(:created_by_id => 1, :title => "some article 2")
+
+      website_section = WebsiteSection.create(:title => "section title")
+      article.website_sections << website_section
+      article2.website_sections << website_section
+
+      results = Content.find_by_section_id_filtered_by_id(1, [1])
+      results.should include(article)
+      results.should_not include(article2)
+    end
+  end
+
+  describe "self.find_published_by_section" do
+    it "should return all content versions that belong to the given website version and section" do
+      @website = Website.create(:name => "Some Site")
+      @website.hosts << WebsiteHost.create(:host => "some_host")
+      @website.website_sections << WebsiteSection.create(:title => "section title")
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article")
+
+      website_section = WebsiteSection.find(1)
+      article.website_sections << website_section
+
+      article.publish(Website.find(1), "some comment", 1, User.find(1))
+      @website.set_publication_version(1.1, 1)
+
+      article2 = Article.create(:created_by_id => 1, :title => "some article 2")
+      article2.website_sections << website_section
+
+      article_version = article.versions.first
+      article_version2 = article2.versions.first
+
+      results = Content.find_published_by_section(PublishedWebsite.find_by_version(0.1), WebsiteSection.find(1))
+      results.should include(article_version)
+      results.should_not include(article_version2)
+    end
+  end
+
+  describe "self.find_published_by_section_with_tag" do
+    it "should return all content version that belong to the given active_publication and section that have the given tag" do
+      @website = Website.create(:name => "Some Site")
+      @website.hosts << WebsiteHost.create(:host => "some_host")
+      @website.website_sections << WebsiteSection.create(:title => "section title")
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      website_section = WebsiteSection.find(1)
+      article.website_sections << website_section
+
+      article.publish(Website.find(1), "some comment", 1, User.find(1))
+      @website.set_publication_version(1.1, 1)
+
+      article2 = Article.create(:created_by_id => 1, :title => "some article 2")
+      article2.website_sections << website_section
+
+      article_version = article.versions.first
+      article_version2 = article2.versions.first
+
+      tag = ActsAsTaggableOn::Tag.find_by_name("some tag")
+
+      results = Content.find_published_by_section_with_tag(PublishedWebsite.find_by_version(0.1), WebsiteSection.find(1), tag)
+      results.should include(article_version)
+      results.should_not include(article_version2)
+    end
+  end
+
+  describe "find_website_sections_by_site_id" do
+    it "should return all the website sections the content belongs to in the given website" do
+      @website = Website.create(:name => "Some Site")
+      @website.hosts << WebsiteHost.create(:host => "some_host")
+      @website.website_sections << WebsiteSection.create(:title => "section title")
+      @website.website_sections << WebsiteSection.create(:title => "section title 2")
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      website_section = WebsiteSection.find(1)
+      website_section2 = WebsiteSection.find(2)
+      article.website_sections << website_section
+      article.website_sections << website_section2
+      
+      @website2 = Website.create(:name => "Some Other Site")
+      @website2.hosts << WebsiteHost.create(:host => "some_other_host")
+      @website2.website_sections << WebsiteSection.create(:title => "section other title")
+
+      other_website_section = WebsiteSection.find_by_title("section other title")
+      article.website_sections << other_website_section
+
+      results = article.find_website_sections_by_site_id(1)
+      results.should include(website_section)
+      results.should include(website_section2)
+      results.should_not include(other_website_section)
+    end
+  end
+
+  describe "position" do
+    it "should return the position of the content in the website_section with the given id" do
+      @website = Website.create(:name => "Some Site")
+      @website.hosts << WebsiteHost.create(:host => "some_host")
+      @website.website_sections << WebsiteSection.create(:title => "section title")
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      website_section = WebsiteSection.find(1)
+      article.website_sections << website_section
+      
+      article.position(1).should eq(0)
+    end
+  end
+
+  describe "add_comment" do
+    it "should add a comment to the article" do
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      article.add_comment(:comment => "some comment")
+
+      article.comments.first.comment.should eq("some comment")
+    end
+  end
+
+  describe "get_comments" do
+    it "should return all comments for an article limited by the given limit" do
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      article.add_comment(:comment => "some comment")
+
+      article.get_comments(1).first.comment.should eq("some comment")
+    end
+  end
+
+  describe "update_content_area_and_position_by_section" do
+    it "should update the content area and position of the content in the given section" do
+      @website = Website.create(:name => "Some Site")
+      @website.hosts << WebsiteHost.create(:host => "some_host")
+      @website.website_sections << WebsiteSection.create(:title => "section title")
+      WorkflowProcess.create(:internal_identifier => "test_content_mgmt", :process_template => true)
+      WorkflowStep.create(:internal_identifier => "Start", :executable_command_id => 1, :executable_command_type => "ManualWorkflowStep", :workflow_process_id => 1, :initial_step => true)
+      article = Article.create(:created_by_id => 1, :title => "some article", :tag_list => "some tag")
+
+      website_section = WebsiteSection.find(1)
+      article.website_sections << website_section
+
+      article.update_content_area_and_position_by_section(website_section, "some_area", 1)
+
+      article.position(1).should eq(1)
+      website_section_content = WebsiteSectionContent.where('content_id = ? and website_section_id = ?',article.id, 1).first
+      website_section_content.content_area.should eq("some_area")
+    end
+  end
+end

data/spec/models/documented_item_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe DocumentedItem, "klass?" do
+  let!(:article) { Factory.create(:article)}
+  let!(:klass_documented_item) { Factory.create(:documented_item, :documented_klass => 'Article')}
+  let!(:non_klass_documented_item) { Factory.create(:documented_item, :documented_content_id => article.id)}
+  
+  it "should return true if klass isn't nil" do
+    klass_documented_item.klass?.should be_true
+  end
+  
+  it "should return false if klass is nil" do
+    non_klass_documented_item.klass?.should be_false
+  end
+end
+
+describe DocumentedItem, "content?" do
+  let!(:article) { Factory.create(:article)}
+  let!(:content_documented_item) { Factory.create(:documented_item, :documented_content_id => article.id)}
+  let!(:non_content_documented_item) { Factory.create(:documented_item, :documented_klass => 'Article')}
+  
+  it "should return true if documented_content_id isn't nil" do
+    content_documented_item.content?.should be_true
+  end
+  
+  it "should return false if documented_content_id is nil" do
+    non_content_documented_item.content?.should be_false
+  end
+end

data/spec/models/online_document_section_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe OnlineDocumentSection, "#build_section_hash" do
+  let!(:website) { Factory.create(:website, :name => "Website")}
+  let!(:root_section) { Factory.create(:online_document_section, :title => "Parent", :website => website, :in_menu => true)}
+  let!(:root_documented_content) { Factory.create(:documented_content, :title => "Parent")}
+  let!(:root_documented_item) { Factory.create(:documented_item, 
+                                            :online_document_section => root_section, 
+                                            :documented_content_id => root_documented_content.id, 
+                                            :online_document_section => root_section) }
+  
+  let!(:child_section) { Factory.create(:online_document_section, :title => "Child", :parent => root_section, :website => website, :in_menu => true)}                                          
+  let!(:child_documented_content) { Factory.create(:documented_content, :title => "Child")}
+  let!(:child_documented_item) { Factory.create(:documented_item, 
+                                            :online_document_section => child_section, 
+                                            :documented_content_id => child_documented_content.id, 
+                                            :online_document_section => child_section) }
+                                            
+  before do
+    root_section.update_path!
+    @root_section_hash = {:name=>"Parent", :has_layout=>false, :type=>"OnlineDocumentSection", :in_menu=>true, :roles=>[], 
+      :path=>"/parent", :permalink=>"parent", :internal_identifier=>"parent", 
+      :online_document_sections=>[{:name=>"Child", :has_layout=>false, :type=>"OnlineDocumentSection", :in_menu=>true, 
+        :roles=>[], :path=>"/parent/child", :permalink=>"child", :internal_identifier=>"child", :online_document_sections=>[], 
+        :documented_item=>{:name=>"Child", :display_title=>nil, :internal_identifier=>"child"}}], 
+      :documented_item=>{:name=>"Parent", :display_title=>nil, :internal_identifier=>"parent"}}
+  end
+  
+  it "should output the correct hash" do
+    root_section.build_section_hash.should == @root_section_hash
+  end
+  
+  
+end