constructor-cms 0.7.3 → 0.7.4

data/pages/spec/features/constructor_pages/templates_spec.rb

@@ -1,267 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module ConstructorPages
-  describe 'Templates Controller' do
-    before :all do
-      ConstructorCore::User.delete_all
-      @user = ConstructorCore::User.create email: 'ivanzotov@gmail.com', password: '123qweASD'
-    end
-
-    before :each do
-      Page.delete_all
-      Field.delete_all
-      Template.delete_all
-
-      Field::TYPES.each do |t|
-        "constructor_pages/types/#{t}_type".classify.constantize.delete_all
-      end
-
-      login_as @user
-    end
-
-    describe 'Index' do
-      describe 'Access' do
-        it 'should be accessed by pages.templates_path if logged in' do
-          visit pages.templates_path
-          current_path.should == pages.templates_path
-          status_code.should == 200
-        end
-
-        it 'should not be accessed by pages.templates_path if not logged in' do
-          logout
-          visit pages.templates_path
-          current_path.should == '/'
-        end
-      end
-
-      it 'should has new template link' do
-        visit pages.templates_path
-        page.should have_link 'New template', pages.new_template_path
-      end
-
-      it 'should has list of templates' do
-        Template.create name: 'Page', code_name: 'page'
-        visit pages.templates_path
-        page.should have_selector 'ul li'
-        page.should have_text 'Page'
-      end
-
-      it 'should has edit_template link' do
-        _template = Template.create name: 'Page', code_name: 'page'
-        visit pages.templates_path
-        page.should have_link 'Edit template', pages.edit_template_path(_template)
-      end
-
-      it 'should has delete_page link' do
-        _template = Template.create name: 'Page', code_name: 'page'
-        visit pages.templates_path
-        page.should have_link 'Delete', pages.template_path(_template)
-      end
-    end
-
-    describe 'Moving' do
-      it 'should move template' do
-        _template_first = Template.create name: 'First', code_name: 'first'
-        _template_second = Template.create name: 'Second', code_name: 'second'
-        _template_third = Template.create name: 'Third', code_name: 'third'
-
-        _template_first.left_sibling.should be_nil
-        _template_first.right_sibling.should == _template_second
-
-        _template_second.left_sibling.should == _template_first
-        _template_second.right_sibling.should == _template_third
-
-        _template_third.left_sibling.should == _template_second
-        _template_third.right_sibling.should be_nil
-
-        visit pages.templates_path
-
-        find("a[href='#{pages.template_move_down_path(_template_first.id)}']").click
-
-        _template_first.reload
-        _template_first.left_sibling.should == _template_second
-        _template_first.right_sibling.should == _template_third
-
-        _template_second.reload
-        _template_second.left_sibling.should be_nil
-        _template_second.right_sibling.should == _template_first
-
-        _template_third.reload
-        _template_third.left_sibling.should == _template_first
-        _template_third.right_sibling.should be_nil
-
-        find("a[href='#{pages.template_move_up_path(_template_third.id)}']").click
-
-        _template_first.reload
-        _template_first.left_sibling.should == _template_third
-        _template_first.right_sibling.should be_nil
-
-        _template_second.reload
-        _template_second.left_sibling.should be_nil
-        _template_second.right_sibling.should == _template_third
-
-        _template_third.reload
-        _template_third.left_sibling.should == _template_second
-        _template_third.right_sibling.should == _template_first
-      end
-    end
-
-    describe 'New template' do
-      describe 'Access' do
-        it 'should be accessed by new_template_path if logged in' do
-          visit pages.new_template_path
-          current_path.should == pages.new_template_path
-          status_code.should == 200
-        end
-
-        it 'should not be accessed by new_template_path if not logged in' do
-          logout
-          visit pages.new_template_path
-          current_path.should == '/'
-        end
-      end
-
-      it 'should has name field' do
-        visit pages.new_template_path
-        page.should have_field 'Name'
-      end
-
-      it 'should has code_name field' do
-        visit pages.new_template_path
-        page.should have_field 'Code name'
-      end
-
-      it 'should has parent and child selects' do
-        visit pages.new_template_path
-        page.should have_select 'Parent'
-        page.should have_select 'Child'
-      end
-
-      it 'should not has link new field' do
-        visit pages.new_template_path
-        page.should_not have_link 'New field'
-      end
-
-      it 'should not has delete link' do
-        visit pages.new_template_path
-        page.should_not have_link 'Delete template'
-      end
-
-      it 'should has Create Template button' do
-        visit pages.new_template_path
-        page.should have_button 'Create Template'
-      end
-
-      it 'should create new template' do
-        visit pages.new_template_path
-        fill_in 'Name', with: 'Brand'
-        fill_in 'Code name', with: 'brand'
-        Template.count.should == 0
-        click_button 'Create Template'
-        current_path.should == pages.templates_path
-        Template.count.should == 1
-        _template = Template.first
-        _template.name.should == 'Brand'
-        _template.code_name.should == 'brand'
-        page.should have_text 'added successfully'
-      end
-
-      it 'should validate uniqueness of code name' do
-        Template.create name: 'Brand', code_name: 'brand'
-        visit pages.new_template_path
-        fill_in 'Name', with: 'Brand'
-        fill_in 'Code name', with: 'brand'
-        click_button 'Create Template'
-        current_path.should == pages.templates_path
-        page.should have_text 'Code name has already been taken'
-      end
-
-      it 'should validate uniqueness of code name with Page' do
-        visit pages.new_template_path
-        fill_in 'Name', with: 'Brand'
-        fill_in 'Code name', with: 'get_field_value'
-        Template.count.should == 0
-        click_button 'Create Template'
-        Template.count.should == 0
-        page.should have_text 'Code name has already been taken'
-      end
-    end
-
-    describe 'Edit template' do
-      before :each do
-        @template = Template.create name: 'Page', code_name: 'page'
-      end
-
-      describe 'Access' do
-        it 'should be accessed by edit_template_path if logged in' do
-          visit pages.edit_template_path(@template)
-          status_code.should == 200
-        end
-
-        it 'should not be accessed by edit_template_path if not logged in' do
-          logout
-          visit pages.edit_template_path(@template)
-          current_path.should == '/'
-        end
-      end
-
-      it 'should has delete link' do
-        visit pages.edit_template_path(@template)
-        page.should have_link 'Delete template'
-      end
-
-      it 'should has new field link' do
-        visit pages.edit_template_path(@template)
-        page.should have_link 'New field', pages.new_field_path(@template)
-      end
-
-      it 'should has update template button' do
-        visit pages.edit_template_path(@template)
-        page.should have_button 'Update Template'
-      end
-
-      it 'should edit template' do
-        visit pages.edit_template_path(@template)
-        fill_in 'Name', with: 'New brand'
-        fill_in 'Code name', with: 'new_brand'
-        click_button 'Update Template'
-        @template.reload
-        @template.name.should == 'New brand'
-        @template.code_name.should == 'new_brand'
-        page.should have_text 'updated successfully'
-      end
-    end
-
-    describe 'Delete template' do
-      it 'should delete from templates index' do
-        Template.create name: 'Page', code_name: 'page'
-        visit pages.templates_path
-        Template.count.should == 1
-        click_link 'Delete'
-        Template.count.should == 0
-        page.should have_text 'removed successfully'
-      end
-
-      it 'should delete from template' do
-        _template = Template.create name: 'Page', code_name: 'page'
-        visit pages.edit_template_path(_template)
-        Template.count.should == 1
-        click_link 'Delete'
-        Template.count.should == 0
-        page.should have_text 'removed successfully'
-      end
-
-      it 'should not delete if there are any pages' do
-        _template = Template.create name: 'Page', code_name: 'page'
-        Page.create name: 'Home page', template: _template
-        visit pages.edit_template_path(_template)
-        Template.count.should == 1
-        click_link 'Delete'
-        Template.count.should == 1
-        page.should have_text 'Delete pages with this template before'
-      end
-    end
-  end
-end

data/pages/spec/models/constructor_pages/field_spec.rb

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module ConstructorPages
-  describe Field do
-    before :each do
-      Template.delete_all
-      @template = Template.create name: 'Page', code_name: 'page'
-
-      Field.delete_all
-      Field::TYPES.each do |t|
-        "constructor_pages/types/#{t}_type".classify.constantize.delete_all
-      end
-    end
-
-    describe '.create' do
-      it 'should be valid' do
-        _field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        _field.should be_valid
-      end
-
-      it 'should create page fields' do
-        _field = Field.create name: 'Price', code_name: 'price', template: @template, type_value: 'text'
-
-        _page = Page.create name: 'Page', template_id: @template.id
-        _page.price.should == ''
-      end
-    end
-
-    describe '#destroy' do
-      it 'should destroy page fields' do
-        _field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        _page = Page.create name: 'Page', template: @template
-
-        _page.content.should == ''
-        _field.destroy
-        _page.content.should be_nil
-      end
-    end
-
-    describe '#type_class' do
-      it 'should return constant of type_value' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'html'
-        field.type_class.should == Types::HtmlType
-
-        field.type_value = 'text'
-        field.type_class.should == Types::TextType
-      end
-    end
-
-    describe '#find_type_object' do
-      it 'should find one object of type_value by page' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        page = Page.create name: 'Page', template: @template
-
-        text_type = Types::TextType.find_by_field_id_and_page_id field.id, page.id
-
-        field.find_type_object(page).should == text_type
-      end
-    end
-
-    describe '#create_type_object' do
-      it 'should create object of type_value by page' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        page = Page.create name: 'Page', template: @template
-
-        text_type = field.create_type_object(page)
-        text_type.should be_an_instance_of(Types::TextType)
-        text_type.page_id.should == page.id
-        text_type.field_id.should == field.id
-      end
-    end
-
-    describe '#remove_type_object' do
-      it 'should remote object of type_value by page' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        page = Page.create name: 'Page', template: @template
-
-        field.find_type_object(page).should be_an_instance_of(Types::TextType)
-
-        field.remove_type_object(page)
-        field.find_type_object(page).should be_nil
-      end
-    end
-
-    describe '#get_value_for' do
-      it 'should get value of type field by page' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        page = Page.create name: 'Page', template: @template
-        page.content = 'Hello world'
-
-        field.get_value_for(page).should == 'Hello world'
-      end
-    end
-
-    describe '#set_value_for' do
-      it 'should set value for type field by page' do
-        field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        page = Page.create name: 'Page', template: @template
-
-        field.set_value_for(page, 'Hello')
-        page.content.should == 'Hello'
-      end
-    end
-
-    describe '#code_name' do
-      it 'should be uniqueness in scope fields' do
-        Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-        _field = Field.create name: 'Content 2', code_name: 'content', template: @template, type_value: 'html'
-
-        _field.should_not be_valid
-      end
-
-      it 'should be uniqueness in scope Page' do
-        _field = Field.create name: 'Content', code_name: 'get_field_value', template: @template, type_value: 'text'
-        _field.should_not be_valid
-      end
-
-      it 'should be uniqueness in scope Template branch' do
-        _template = Template.create name: 'Brand', code_name: 'brand', parent: @template
-        @template.reload
-
-        _field = Field.create name: 'Content', code_name: 'brand', template: @template, type_value: 'text'
-        _field.should_not be_valid
-
-        _field.code_name = 'brands'
-        _field.should_not be_valid
-
-        _field.code_name = 'price'
-        _field.should be_valid
-      end
-    end
-  end
-end

data/pages/spec/models/constructor_pages/page_spec.rb

@@ -1,420 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module ConstructorPages
-  describe Page do
-    before :each do
-      Template.delete_all
-      @template = Template.create name: 'Page', code_name: 'page'
-
-      Page.delete_all
-      Field.delete_all
-      Types::TextType.delete_all
-    end
-
-    context 'CLASS METHODS' do
-      describe '.create' do
-        it 'should be valid' do
-          Page.create.valid?.should be_true
-        end
-
-        it 'should create type_fields after' do
-          field = Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-          page = Page.create name: 'New page', template: @template
-
-          field.get_value_for(page).should == ''
-        end
-      end
-
-      describe '.find_by_request_or_first' do
-        before :each do
-          @page = Page.create name: 'New page', url: 'new-page'
-        end
-
-        it 'should return page by given request path' do
-          Page.find_by_request_or_first('/new-page').should == @page
-        end
-
-        it 'should return first page if no given request or request is home page' do
-          Page.find_by_request_or_first.should == @page
-          Page.find_by_request_or_first('/').should == @page
-        end
-      end
-
-      describe '.full_url_generate' do
-        it 'should generate full_url from parent_id and url' do
-          first_page = Page.create name: 'First page', url: 'first-page'
-          second_page = Page.create name: 'Second page', url: 'second-page', parent: first_page
-          Page.full_url_generate(second_page.id, 'third-page').should == '/first-page/second-page/third-page'
-        end
-      end
-
-      describe '.check_code_name' do
-        it 'should check existing code_name in instance_methods' do
-          Page.check_code_name('get_field_value').should be_false
-          Page.check_code_name('class').should be_false
-          Page.check_code_name('hello_world').should be_true
-        end
-      end
-    end
-
-    describe 'SEARCH' do
-      before :each do
-        @price_field = Field.create name: 'Price', code_name: 'price', template: @template, type_value: 'float'
-        @area_field = Field.create name: 'Area', code_name: 'area', template: @template, type_value: 'integer'
-
-        @brand_template = Template.create name: 'Brand', code_name: 'brand', parent: @template
-        @content_field = Field.create name: 'Content', code_name: 'content', template: @brand_template, type_value: 'text'
-        @check_field = Field.create name: 'Check', code_name: 'check', template: @brand_template, type_value: 'boolean'
-        @brand_price_field = Field.create name: 'Price', code_name: 'price', template: @brand_template, type_value: 'float'
-        @brand_area_field = Field.create name: 'Area', code_name: 'area', template: @brand_template, type_value: 'integer'
-
-        @page = Page.create name: 'Fresco', template: @template
-        @page.price = 15000
-        @page.area = 35
-
-        @second_page = Page.create name: 'Zanussi', template: @template
-        @second_page.price = 1000
-        @second_page.area = 10
-
-        @first_brand_page = Page.create name: 'Midea', template: @brand_template, parent: @page
-        @first_brand_page.price = 20000
-        @first_brand_page.area = 25
-        @first_brand_page.content = 'This is first brand page'
-        @first_brand_page.check = true
-
-        @second_brand_page = Page.create name: 'Dantex', template: @brand_template, parent: @page
-        @second_brand_page.price = 30000
-        @second_brand_page.area = 55
-        @second_brand_page.content = 'This is second brand page'
-        @second_brand_page.check = false
-
-        @third_brand_page = Page.create name: 'LG', template: @brand_template, parent: @second_page
-        @third_brand_page.price = 10000
-        @third_brand_page.area = 38
-        @third_brand_page.content = 'This is third brand page'
-        @third_brand_page.check = true
-
-        @page.reload
-        @second_page.reload
-      end
-
-      context 'search in all pages' do
-        it 'should search with what search' do
-          Page.search.should == [@page, @first_brand_page, @second_brand_page, @second_page, @third_brand_page]
-          Page.search(:hello).should == []
-          Page.search(:brand).should == [@first_brand_page, @second_brand_page, @third_brand_page]
-          Page.search(:brands).should == [@first_brand_page, @second_brand_page, @third_brand_page]
-        end
-
-        it 'should search with where string search' do
-          Page.search_in('/world').should == []
-        end
-
-        it 'should search with where page search' do
-          Page.search_in(@page).should == [@first_brand_page, @second_brand_page]
-          Page.in(@second_page).search(:brands).should == [@third_brand_page]
-          Page.in(@second_page).search(:brand).should == [@third_brand_page]
-          Page.in(@second_page).search('brand').should == [@third_brand_page]
-        end
-
-        it 'it should search with by params' do
-          Page.in(@page).search_by(area: 25).should == [@first_brand_page]
-          Page.search_by(area: 10).should == [@second_page]
-          Page.search_by(price: 15000).should == [@page]
-          Page.in(@page).by(area: 25).search(:brand).should == [@first_brand_page]
-          Page.in(@second_page).by(area: 38).search(:brand).should == [@third_brand_page]
-          Page.in(@second_page).by(area: 40).search(:brand).should == []
-          Page.in('/world').search_by(area: 10).should == []
-        end
-
-        it 'should search with less' do
-          pending#Page.search(price: ['<', 20000]).should == [@page]
-        end
-
-        it 'should search with more' do
-          pending#Page.search(price: ['<', 20000], price: ['>', 5000]).should == [@page, @second_page]
-        end
-      end
-
-      context 'search in certain page' do
-        it 'should search with what search' do
-          @page.search.should == [@first_brand_page, @second_brand_page]
-          @page.search(:hello).should == []
-          @page.search(:brand).should == [@first_brand_page, @second_brand_page]
-          @second_page.search(:brand).should == [@third_brand_page]
-        end
-
-        it 'it should search with by params' do
-          @page.search_by(area: 25).should == [@first_brand_page]
-          @page.search_by(price: 30000).should == [@second_brand_page]
-          @page.by(price: 30000).search.should == [@second_brand_page]
-          @page.search_by(area: 10).should == []
-          @page.by(area: 10).search.should == []
-        end
-      end
-    end
-
-
-    context 'INSTANCE METHODS' do
-      context 'Getting and setting field value' do
-        before :each do
-          @template = Template.create name: 'Page template', code_name: 'page_template'
-          @page = Page.create name: 'Home page', template: @template
-          @field = Field.create name: 'Desc', code_name: 'desc', template: @template, type_value: 'text'
-        end
-
-        describe '#get_field' do
-          it 'should get value from type_field' do
-            @field.set_value_for(@page, 'Hello world')
-            @page.get_field_value('desc').should == 'Hello world'
-          end
-        end
-
-        describe '#set_field' do
-          it 'should set value for type_field' do
-            @page.set_field_value('desc', 'my world')
-            @field.get_value_for(@page).should == 'my world'
-          end
-        end
-      end
-
-      context 'Updating and removing fields values' do
-        before :each do
-          @template = Template.create name: 'New template', code_name: 'brand'
-          @field = Field.create name: 'Price', code_name: 'price', template: @template, type_value: 'float'
-          @page = Page.create name: 'New page', template: @template
-          @page.price = 500
-        end
-
-        describe '#update_fields_values' do
-          it 'should update fields values with params' do
-            @template.reload
-            Field.create name: 'Count', code_name: 'amount', template: @template, type_value: 'integer'
-
-            @page.reload
-
-            @page.amount = 10
-
-            @page.update_fields_values({price: 1000, amount: 20})
-
-            @page.price.should == 1000
-            @page.amount.should == 20
-          end
-
-          it 'should reset boolean fields' do
-            Field.create name: 'Check', code_name: 'check', template: @template, type_value: 'boolean'
-
-            @page.check = true
-
-            @page.update_fields_values({price: 1000})
-
-            @page.price.should == 1000
-            @page.check.should be_false
-          end
-        end
-
-        describe '#remove_fields_values' do
-          it 'should destroy all type_values fields' do
-            @field.find_type_object(@page).value.should == 500
-
-            @page.remove_fields_values
-            @field.find_type_object(@page).should be_nil
-          end
-        end
-      end
-
-      describe '#find_page_in_branch' do
-        it 'should find page(s) in same branch pages and templates by template_code_name' do
-          brand_template = Template.create name: 'Brand', code_name: 'brand'
-          series_template = Template.create name: 'Series', code_name: 'series', parent: brand_template
-
-          brand_page = Page.create name: 'Zanussi', template: brand_template
-          series_page = Page.create name: 'Fresco', template: series_template, parent: brand_page
-          brand_page.reload
-
-          series_page.find_page_in_branch('brand').should == brand_page
-          brand_page.find_pages_in_branch('series').should == [series_page]
-        end
-      end
-
-      describe '#as_json' do
-        context 'should return page hash attributes with fields' do
-          before :each do
-            @template = Template.create name: 'Json', code_name: 'json_template'
-            @page = Page.create name: 'Test json', template: @template
-          end
-
-          it 'should return defaults name and title attrs' do
-            @page.as_json.should == {name: @page.name, title: @page.title}
-          end
-
-          it 'should add fields to hash' do
-            Field.create name: 'Content', code_name: 'content', template: @template, type_value: 'text'
-            @page.content = 'Hello world'
-            @page.reload
-
-            @page.as_json.should == {name: @page.name, title: @page.title, content: 'Hello world'}
-          end
-        end
-      end
-
-      describe '#redirect?' do
-        it 'should check if link specified or not' do
-          page = Page.create name: 'Test redirection'
-          page.redirect?.should be_false
-
-          page.link = ''
-          page.save
-
-          page.redirect?.should be_false
-
-          page.link = '/hello-redirect'
-          page.save
-
-          page.redirect?.should be_true
-        end
-      end
-    end
-
-    context 'ATTRIBUTES' do
-      describe '#auto_url' do
-        it 'should be true by default' do
-          page = Page.create
-          page.auto_url.should be_true
-        end
-      end
-
-      describe '#template' do
-        context 'if there is no template' do
-          it 'should not be valid' do
-            Template.delete_all
-
-            page = Page.create
-            page.valid?.should_not be_true
-          end
-        end
-
-        context 'if template_id is nil' do
-          it 'should be first template' do
-            page = Page.create
-            page.template.should == Template.first
-          end
-        end
-      end
-
-      describe '#url' do
-        context 'if url is empty or if auto_url is true' do
-          it 'should be generated from name' do
-            page = Page.create name: 'Hello world'
-            page.url.should == 'hello-world'
-          end
-
-          it 'should translit utf-8' do
-            page = Page.create name: 'Проверка'
-            page.full_url.should == '/proverka'
-
-            page_two = Page.create name: 'Тест', parent: page
-            page_two.full_url.should == '/proverka/test'
-          end
-        end
-
-        context 'else' do
-          it 'should get url field value' do
-            page = Page.create name: 'Hello', auto_url: true
-            page.url.should == 'hello'
-
-            page.auto_url = false
-            page.url = 'world'
-            page.save
-            page.url.should == 'world'
-
-            page.auto_url = true
-            page.name = 'Another world'
-            page.url = 'world-two'
-            page.save
-            page.url.should == 'another-world'
-          end
-        end
-      end
-
-      describe '#full_url' do
-        it 'should be generated from url and ancestors' do
-          page = Page.create name: 'Hello'
-          page.full_url.should == '/hello'
-
-          page_two = Page.create name: 'World', parent: page
-          page_two.full_url.should == '/hello/world'
-        end
-
-        context 'if parent or url has been changed' do
-          it 'should update full_url' do
-            page = Page.create name: 'Change url', url: 'change-url', auto_url: false
-            child_page = Page.create name: 'Child page', url: 'child', auto_url: false, parent: page
-            page.reload
-
-            page.full_url.should == '/change-url'
-            child_page.full_url.should == '/change-url/child'
-
-            page.url = 'another-change-url'
-            page.save
-            page.full_url.should == '/another-change-url'
-
-            child_page.reload
-            child_page.full_url.should == '/another-change-url/child'
-          end
-        end
-
-        context 'if parent is root or nil' do
-          it 'should be as /self.url' do
-            page = Page.create name: 'Page', url: 'page', auto_url: false, parent_id: nil
-            page.full_url.should == '/page'
-
-            parent = Page.create name: 'Parent'
-            page.parent = parent
-            page.save
-
-            page.full_url.should == '/parent/page'
-
-            page.parent = nil
-            page.save
-            page.full_url.should == '/page'
-          end
-        end
-      end
-
-      describe 'method_missing' do
-        context 'Getting and setting field value' do
-          before :each do
-            @template = Template.create name: 'Page', code_name: 'page_template'
-            @page = Page.create name: 'No method', template: @template
-            @field = Field.create name: 'Content', code_name: 'desc', template: @template, type_value: 'text'
-          end
-
-          it 'should return value of type_value for missing method' do
-            @field.set_value_for(@page, 'my world')
-            @page.desc.should == 'my world'
-          end
-
-          it 'should set value for type_value for missing method' do
-            @page.desc = 'my world 2'
-            @field.get_value_for(@page).should == 'my world 2'
-          end
-        end
-
-        it 'should find page in branch template if no field found' do
-          brand_template = Template.create name: 'Brand', code_name: 'brand'
-          series_template = Template.create name: 'Series', code_name: 'series', parent: brand_template
-
-          brand_page = Page.create name: 'Zanussi', template: brand_template
-          series_page = Page.create name: 'Fresco', template: series_template, parent: brand_page
-          brand_page.reload
-
-          series_page.brand.should == brand_page
-          brand_page.series.should == [series_page]
-        end
-      end
-    end
-  end
-end