instedd-pigeon 0.1.1

data/spec/helpers/pigeon/renderer/channel_renderer_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Pigeon
+  module Renderer
+    describe "ChannelRenderer" do
+      before(:each) do
+        @channel = Channel.new foo: '42'
+        @renderer = ChannelRenderer.new @channel
+      end
+
+      it "should handle @field commands" do
+        @renderer.render(['@field', 'foo']).should have_tag('input', with: {
+          name: 'foo', value: '42'
+        })
+      end
+
+      it "should handle @label commands" do
+        @renderer.render(['@label', 'foo']).should have_tag('label', with: {
+          :for => 'foo' }, text: 'Foo')
+      end
+
+      it "should handle @attr commands" do
+        @renderer.render(['@attr', 'foo']).should have_tag('div') do
+          with_tag 'label', with: { :for => 'foo' }
+          with_tag 'input', with: { :name => 'foo', :value => '42' }
+        end
+      end
+
+      it "should handle @hidden commands" do
+        @renderer.render(['@hidden', 'foo']).should have_tag('input', with: {
+          name: 'foo', type: 'hidden'
+        })
+      end
+
+      it "should accept options for attribute commands" do
+        @renderer.render(['@attr', { "class" => "field" }, 'foo']).should \
+            have_tag('div', with: { 'class' => 'field' }) do
+          with_tag 'label'
+          with_tag 'input'
+        end
+      end
+
+      context "with a scope" do
+        before(:each) do
+          @channel = Channel.new foo: '42'
+          @renderer = ChannelRenderer.new @channel, 'channel_data'
+        end
+
+        it "should add a scope attribute to @template and @wizard commands" do
+          @renderer.render(['@template']).should have_tag('div', with: {
+            "data-scope" => "channel_data"
+          })
+          @renderer.render(['@wizard']).should have_tag('div', with: {
+            "data-scope" => "channel_data"
+          })
+        end
+      end
+    end
+  end
+end
+

data/spec/helpers/pigeon/tag_helper_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+# Specs in this file have access to a helper object that includes
+# the TagHelper. For example:
+#
+# describe TagHelper do
+#   describe "string concat" do
+#     it "concats two strings with spaces" do
+#       helper.concat_strings("this","that").should == "this that"
+#     end
+#   end
+# end
+module Pigeon
+  describe TagHelper do
+    describe "pigeon_schema_options" do
+      before(:each) do
+        @schemas = NuntiumChannel.schemas
+      end
+
+      it "returns a list of schemas appropiate for options_for_select" do
+        options = helper.pigeon_schema_options(@schemas)
+        options.count.should eq(@schemas.count)
+        options.all? { |o| 
+          o.respond_to?(:first) && o.respond_to?(:last) 
+        }.should be_true
+      end
+
+      it "prefixes values with given string" do
+        options = helper.pigeon_schema_options(@schemas, 'foo/')
+        options.all? { |o|
+          o.last.starts_with? 'foo/'
+        }.should be_true
+      end
+    end
+  end
+end

data/spec/helpers/pigeon/template_helper_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Pigeon
+  describe TemplateHelper do
+    describe "pigeon_render_template" do
+      it "should render static templates" do
+        helper.pigeon_render_template(["div"]).should eq("<div></div>")
+      end
+
+      it "should delegate commands to the given block" do
+        out = helper.pigeon_render_template(["@x"]) do |args|
+          args.first.should eq("@x")
+          "x marks the spot"
+        end
+        out.should eq("x marks the spot")
+      end
+
+      it "should render unhandled commands as an empty string" do
+        helper.pigeon_render_template(["@x"]).should eq("")
+      end
+    end
+
+    describe "pigeon_render_channel_template" do
+      before(:each) do
+        @schema = ChannelSchema.from_hash 'nuntium', test_schema_hash('foobar')
+        @channel = Channel.new schema: @schema
+      end
+
+      it "should render the given template with attributes from the channel" do
+        helper.pigeon_render_channel_template(@channel, ['@field', 'ticket_code'], nil).
+          should have_tag('input', with: { name: 'ticket_code' })
+      end
+
+      it "should render the channel's schema template by default" do
+        out = helper.pigeon_render_channel_template(@channel, nil, nil)
+        out.should have_tag('input', with: { name: 'ticket_code' })
+        out.should have_tag('input', with: { name: 'configuration[user]' })
+      end
+
+      it "should delegate unknown commands to the given block" do
+        helper.pigeon_render_channel_template(@channel, ['@x']) do |args|
+          args.first.should eq('@x')
+          'XXX'
+        end.should eq('XXX')
+      end
+
+      it "should by default use the 'channel' scope" do
+        helper.pigeon_render_channel_template(@channel, ['@field', 'ticket_code']).  should have_tag('input', with: { name: 'channel[ticket_code]' })
+      end
+
+      it "should wrap channel's attributes in the given scope" do
+        helper.pigeon_render_channel_template(@channel, ['@field', 'ticket_code'], 'foo').  should have_tag('input', with: { name: 'foo[ticket_code]' })
+      end
+    end
+  end
+end
+

data/spec/models/pigeon/channel_attribute_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module Pigeon
+  describe ChannelAttribute do
+    it "should require a name" do
+      lambda { ChannelAttribute.new nil, 'bar' }.should raise_error(ArgumentError)
+      lambda { ChannelAttribute.new '', 'bar' }.should raise_error(ArgumentError)
+    end
+
+    it "should require a type" do
+      lambda { ChannelAttribute.new 'foo', nil }.should raise_error(ArgumentError)
+    end
+
+    it "should validate type" do
+      lambda { ChannelAttribute.new 'foo', 'bar' }.should raise_error(ArgumentError)
+    end
+
+    it "should set label and humanized name by default" do
+      @attr = ChannelAttribute.new 'foo', :string
+      @attr.label.should_not be_blank
+      @attr.humanized_name.should_not be_blank
+    end
+
+    it "should humanize label and humanized name by default" do
+      @attr = ChannelAttribute.new 'some_field', :string
+      @attr.label.should eq('Some field')
+      @attr.humanized_name.should eq('Some field')
+    end
+
+    it "should set label from humanized name if not given" do
+      @attr = ChannelAttribute.new 'foo', :string, humanized_name: 'bar'
+      @attr.label.should eq('bar')
+      @attr.humanized_name.should eq('bar')
+    end
+
+    it "should set humanized name from label if not given" do
+      @attr = ChannelAttribute.new 'foo', :string, label: 'bar'
+      @attr.label.should eq('bar')
+      @attr.humanized_name.should eq('bar')
+    end
+
+    it "should initialize options to empty array" do
+      @attr = ChannelAttribute.new 'foo', :enum
+      @attr.options.should_not be_nil
+    end
+
+    it "should have a scope" do
+      @attr = ChannelAttribute.new 'foo', :string
+      @attr.should respond_to(:scope)
+      @attr.should respond_to(:scope=)
+    end
+
+    it "should compute its scoped name" do
+      @foo = ChannelAttribute.new 'foo', :string
+      @bar = ChannelAttribute.new 'bar', :string
+      
+      @bar.scoped_name.should eq('bar')
+      @bar.scoped_name('bling').should eq('bling[bar]')
+
+      @bar.scope = @foo
+      @bar.scoped_name.should eq('foo[bar]')
+      @bar.scoped_name('bling').should eq('bling[foo][bar]')
+    end
+
+    describe "build_default" do
+      it "should create a valid string attribute by default" do
+        attr = ChannelAttribute.build_default('foo')
+        attr.should_not be_nil
+        attr.should be_a(ChannelAttribute)
+        attr.type.should eq(:string)
+        attr.name.should eq('foo')
+      end
+
+      it "should create a boolean attribute if the value is boolean" do
+        ChannelAttribute.build_default('foo', true).type.should eq(:boolean)
+        ChannelAttribute.build_default('foo', false).type.should eq(:boolean)
+      end
+
+      it "should create an integer attribute if the value is an integer number" do
+        ChannelAttribute.build_default('foo', 10).type.should eq(:integer)
+      end
+
+      it "should build a scope if the attribute name is scoped" do
+        attr = ChannelAttribute.build_default('foo[bar]')
+        attr.name.should eq('bar')
+        attr.scoped_name.should eq('foo[bar]')
+        attr.scoped_name('baz').should eq('baz[foo][bar]')
+      end
+
+      it "should build a recursive scope if the attribute name is deeply nested" do
+        attr = ChannelAttribute.build_default('baz[foo][bar]')
+        attr.name.should eq('bar')
+        attr.scoped_name.should eq('baz[foo][bar]')
+        attr.scoped_name('outer').should eq('outer[baz][foo][bar]')
+      end
+    end
+  end
+end

data/spec/models/pigeon/channel_schema_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Pigeon
+  describe ChannelSchema do
+    before(:each) do
+      @schema = ChannelSchema.from_hash 'nuntium', test_schema_hash('foobar')
+    end
+
+    context "on initialization" do
+      it "should validate the presence of type" do
+        lambda do
+          ChannelSchema.new '', 'foo'
+        end.should raise_error(ArgumentError)
+      end
+
+      it "should validate the presence of kind" do
+        lambda do
+          ChannelSchema.new 'foo', ''
+        end.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "from_hash" do
+      it "should set the type and kind" do
+        @schema.type.should eq('nuntium')
+        @schema.kind.should eq('foobar')
+      end
+    end
+
+    it "should return only first level attributes as known_attributes" do
+      @schema.known_attributes.sort.should eq(%w(protocol ticket_code configuration).sort)
+    end
+
+    it "should list user attributes including nested ones" do
+      @schema.user_attributes.sort.should eq(%w(ticket_code configuration[user] configuration[password] configuration[port] configuration[send_offline]).sort)
+    end
+
+    it "should build a hash with default values, including nested attributes" do
+      values = @schema.default_values
+      values.count.should eq(2)
+      values.keys.sort.should eq(%w(configuration protocol).sort)
+      values['protocol'].should eq('foobar')
+      values['configuration'].should be_a_kind_of(Hash)
+      values['configuration']['port'].should eq(5222)
+    end
+
+    it "should find shallow attributes" do
+      @schema.find_attribute('protocol').should_not be_nil
+      @schema.find_attribute('protocol').name.should eq('protocol')
+    end
+
+    it "should find nested attributes" do
+      @schema.find_attribute('configuration[port]').should_not be_nil
+      @schema.find_attribute('configuration[port]').name.should eq('port')
+    end
+
+    it "nested attributes should have a scope" do
+      @schema.find_attribute('configuration[port]').scope.should_not be_nil
+      @schema.find_attribute('configuration[port]').scoped_name.
+        should eq('configuration[port]')
+    end
+  end
+end

data/spec/models/pigeon/channel_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module Pigeon
+  describe Channel do
+    it_behaves_like "ActiveModel"
+
+    describe "common attributes" do
+      before(:each) do
+        @channel = Channel.new
+      end
+
+      it "should respond to type" do
+        @channel.should respond_to(:type)
+      end
+
+      ['name', 'kind'].each do |name|
+        it "should respond to #{name}" do
+          @channel.should respond_to(name.to_sym)
+          @channel.should respond_to("#{name}=".to_sym)
+        end
+      end
+    end
+
+    describe "default instantiation" do
+      before(:each) do
+        @channel = Channel.new
+      end
+
+      it "should be of nil type" do
+        @channel.type.should be_nil
+      end
+
+      it "should not be persisted" do
+        @channel.should_not be_persisted
+      end
+    end
+
+    describe "with attributes" do
+      before(:each) do
+        @attributes = { kind: 'foo', name: 'bar', other: true }
+        @channel = Channel.new @attributes
+      end
+
+      it "should set each attribute" do
+        @attributes.each do |k,v|
+          @channel.send(k.to_sym).should eq(v)
+        end
+      end
+      
+      it "should expose attributes through []" do
+        @channel['kind'].should eq(@attributes[:kind])
+        @channel['name'].should eq(@attributes[:name])
+      end
+
+      it "should allow writing attributes through []" do
+        @channel['other'] = false
+        @channel.other.should be_false
+      end
+    end
+
+    describe "with nested attributes" do
+      before(:each) do
+        @config = { foo: 42, bar: 'baz' }
+        @channel = Channel.new configuration: @config
+      end
+
+      it "should dup nested values" do
+        @config.each do |k,v|
+          @channel.configuration[k].should be(@config[k])
+        end
+        @channel.configuration.should_not be(@config)
+      end
+
+      it "should have indifferent access" do
+        @config.each do |k,v|
+          @channel.configuration[k.to_s].should be(@config[k])
+          @channel.configuration[k.to_sym].should be(@config[k])
+        end
+      end
+
+      it "load should merge hashes" do
+        @channel.send(:load, { configuration: { hello: 'world' }})
+        @channel.configuration[:foo].should eq(@config[:foo])
+        @channel.configuration[:bar].should eq(@config[:bar])
+        @channel.configuration[:hello].should eq('world')
+      end
+    end
+
+    describe "validations" do
+      before(:each) do
+        @valid_attributes = { name: 'foo', kind: 'bar' }
+        @channel = Channel.new @valid_attributes
+      end
+
+      it "should be valid with valid attributes" do
+        @channel.should be_valid
+      end
+
+      it "should validate presence of name" do
+        @channel.name = nil
+        @channel.should_not be_valid
+      end
+
+      it "should validate presence of kind" do
+        @channel.kind = nil
+        @channel.should_not be_valid
+      end
+    end
+
+    describe "types and schemas" do
+      it "should find defined types" do
+        %w(nuntium verboice).each do |type|
+          Channel.find_type(type).should_not be_nil
+          Channel.find_type(type.to_sym).should_not be_nil
+          Channel.find_type(type).type.to_s.should eq(type)
+        end
+      end
+
+      it "should return nil for undefined types" do
+        Channel.find_type('foobar').should be_nil
+      end
+
+      context "when initialized with a schema" do
+        before(:each) do
+          @schema = ChannelSchema.from_hash 'nuntium', test_schema_hash('foobar')
+        end
+
+        it "should set the schema" do
+          @channel = Channel.new schema: @schema
+          @channel.schema.should be(@schema)
+        end
+
+        it "should set the kind if none is given" do
+          @channel = Channel.new schema: @schema
+          @channel.kind.should eq(@schema.kind)
+        end
+
+        it "should not override kind if one is given" do
+          @channel = Channel.new schema: @schema, kind: 'dont_override'
+          @channel.kind.should eq('dont_override')
+        end
+
+        it "should not set the schema as an attribute" do
+          @channel = Channel.new schema: @schema
+          @channel.attributes[:schema].should be_nil
+        end
+      end
+    end
+
+    describe "read and write attributes" do
+      before(:each) do
+        @channel = Channel.new foo: 42, bar: { baz: 1, pepe: 'hi' }
+      end
+
+      it "should read shallow and nested attributes" do
+        @channel.read_attribute('foo').should eq(@channel.foo)
+        @channel.read_attribute('bar[baz]').should eq(@channel.bar['baz'])
+        @channel.read_attribute('bar[pepe]').should eq(@channel.bar['pepe'])
+      end
+
+      it "should write shallow and nested attributes" do
+        @channel.write_attribute('foo', 33)
+        @channel.foo.should eq(33)
+
+        @channel.write_attribute('bar[pepe]', 'bye')
+        @channel.bar['pepe'].should eq('bye')
+      end
+
+      it "should return nil when reading unexisting attribute" do
+        @channel.read_attribute('fnord').should be_nil
+        @channel.read_attribute('fnord[foo]').should be_nil
+        @channel.read_attribute('foo[fnord]').should be_nil
+        @channel.read_attribute('bar[fnord]').should be_nil
+      end
+
+      it "should ignore writes to unexisting attributes" do
+        @channel.write_attribute('fnord[foo]', 5).should be_nil
+        @channel.write_attribute('foo[fnord]', 5).should be_nil
+        @channel.write_attribute('bar[fnord][blah]', 5).should be_nil
+      end
+    end
+
+    describe "attributes assignment" do
+      before(:each) do
+        @channel = Channel.new foo: 42, bar: { baz: 1, pepe: 'hi' }
+      end
+
+      it "should assign shallow attributes" do
+        @channel.assign_attributes(foo: 123)
+        @channel.foo.should eq(123)
+      end
+
+      it "should assign nested attributes" do
+        @channel.assign_attributes(bar: { baz: 42 })
+        @channel.bar[:baz].should eq(42)
+      end
+
+      it "should assign scoped attributes" do
+        @channel.assign_attributes('bar[baz]' => 42)
+        @channel.bar[:baz].should eq(42)
+      end
+    end
+  end
+end
+

data/spec/models/pigeon/nuntium_channel_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Pigeon
+  describe NuntiumChannel do
+    describe "basic attributes" do
+      before(:each) do
+        @channel = NuntiumChannel.new
+      end
+
+      it "should be of nuntium type" do
+        @channel.type.should be(:nuntium)
+      end
+
+      [:protocol, :enabled, :direction, :priority].each do |attr|
+        it "should respond to #{attr} methods" do
+          @channel.should respond_to(attr)
+          @channel.should respond_to("#{attr}=")
+        end
+      end
+
+      it "should have default values" do
+        @channel.protocol.should_not be_nil
+        @channel.enabled.should be_true
+        @channel.direction.should eq("bidirectional")
+        @channel.priority.should eq(100)
+      end
+    end
+
+    it "should load static schemas" do
+      NuntiumChannel.schemas.should_not be_empty
+      NuntiumChannel.find_schema('pop3').should_not be_nil
+    end
+
+    describe "when initialized with kind" do
+      before(:each) do
+        @channel = NuntiumChannel.new kind: 'xmpp'
+      end
+
+      it "should find schema" do
+        @channel.schema.should_not be_nil
+      end
+
+      it "should set schema's default values" do
+        @channel.protocol.should eq('xmpp')
+      end
+
+      it "should set nested default schema values" do
+        @channel.configuration['port'].should eq(5222)
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+
+require 'rspec/rails'
+
+ENGINE_RAILS_ROOT = File.join(File.dirname(__FILE__), '../')
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(ENGINE_RAILS_ROOT, "spec/support/**/*.rb")].each {|f| require f }
+
+TEST_DATA_PATH = File.join(File.dirname(__FILE__), 'data')
+
+RSpec.configure do |config|
+  # ## Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{ENGINE_RAILS_ROOT}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+end
+

data/spec/support/active_model_lint.rb

@@ -0,0 +1,15 @@
+shared_examples_for "ActiveModel" do
+  include ActiveModel::Lint::Tests
+ 
+  # to_s is to support ruby-1.9
+  ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m|
+    example m.gsub('_',' ') do
+      send m
+    end
+  end
+ 
+  def model
+    subject
+  end
+end
+

data/spec/support/test_schemas.rb

@@ -0,0 +1,12 @@
+def test_schema_list
+  YAML::load_file(File.join(TEST_DATA_PATH, 'test_schemas.yml'))
+end
+
+def test_schema_hash(key)
+  data = test_schema_list
+  raise ArgumentError, "#{key} schema not defined for testing" \
+    unless data.include?(key)
+  data[key]['kind'] = key
+  data[key]
+end
+