junkfood 0.1.0

data/spec/junkfood/base32_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Junkfood::Base32' do
+  it 'should encode into an ASCII string' do
+    str = Junkfood::Base32.encode '1234567890abcdefghijklmnopqrstuvwxyz'
+    str.string.should eql(
+      'GEZDGNBVGY3TQOJQMFRGGZDFMZTWQ2LKNNWG23TPOBYXE43UOV3HO6DZPI')
+    str.string.encoding.should eql(Encoding::ASCII)
+  end
+
+  it 'should decode into a BINARY string' do
+    str = Junkfood::Base32.decode(
+      'GEZDGNBVGY3TQOJQMFRGGZDFMZTWQ2LKNNWG23TPOBYXE43UOV3HO6DZPI')
+    str.string.should eql('1234567890abcdefghijklmnopqrstuvwxyz')
+    str.string.encoding.should eql(Encoding::BINARY)
+  end
+
+  it 'should treat 0 and O the same' do
+    str1 = Junkfood::Base32.decode('000000000')
+    str2 = Junkfood::Base32.decode('oooOoooOo')
+    str1.string.should eql(str2.string)
+  end
+
+  it 'should treat 1 and i the same' do
+    str1 = Junkfood::Base32.decode('111111111')
+    str2 = Junkfood::Base32.decode('iiiiIIIII')
+    str1.string.should eql(str2.string)
+  end
+
+  it 'should ignore case' do
+    str1 = Junkfood::Base32.decode('12345670abcdefghijklmnopqrstuvwxyz')
+    str2 = Junkfood::Base32.decode('12345670ABCDEFGHIJKLMNOPQRSTUVWXYZ')
+    str1.string.should eql(str2.string)
+  end
+
+  it 'should have optional splitlines'
+
+  it 'should have splitlines at specified lengths'
+end

data/spec/junkfood/ceb/base_command_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'Ceb::BaseCommand' do
+  before :all do
+    @test_class = Class.new(::Junkfood::Ceb::BaseCommand)
+    @test_instance = @test_class.new
+    @test_instance.origin = 'urn:user_id:1234'
+  end
+
+  it 'should respond to new_record?' do
+    @test_instance.respond_to?(:new_record?).should be_true
+  end
+
+  it 'should respond to save!' do
+    @test_instance.respond_to?(:save!).should be_true
+  end
+
+  it 'should respond to valid?' do
+    @test_instance.respond_to?(:valid?).should be_true
+  end
+
+  it 'should have id attribute' do
+    @test_instance.respond_to?(:id).should be_true
+  end
+
+  it 'should have created_at attribute' do
+    @test_instance.respond_to?(:created_at).should be_true
+  end
+
+  it 'should have origin attribute' do
+    @test_instance.respond_to?(:origin).should be_true
+  end
+
+  it 'may have events' do
+    # NOTE: This is not a hard requirement. We mainly want the coupling
+    #  to be looser. It's sufficient for Events to link to Commands,
+    #  and not necesarily need Commands to map to all of its Events.
+    # This test is here because we have a Mongoid MongoDb implementation.
+    @test_instance.respond_to?(:events).should be_true
+  end
+
+  it 'should respond to to_json' do
+    @test_instance.respond_to?(:to_json).should be_true
+  end
+
+  it 'json should have _id attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('_id').should be_true
+  end
+
+  it 'json should have _type attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('_type').should be_true
+  end
+
+  it 'json should have created_at attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('created_at').should be_true
+  end
+
+  it 'json should have origin attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('origin').should be_true
+  end
+
+  it 'should respond to perform' do
+    @test_instance.respond_to?(:perform).should be_true
+  end
+end

data/spec/junkfood/ceb/base_event_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'Ceb::BaseEvent' do
+
+  before :all do
+    @command_class = Class.new(::Junkfood::Ceb::BaseCommand)
+    @command_instance = @command_class.new
+    @test_class = Class.new(::Junkfood::Ceb::BaseEvent)
+    @test_instance = @test_class.new
+    @test_instance.command = @command_instance
+  end
+
+  it 'should respond to new_record?' do
+    @test_instance.respond_to?(:new_record?).should be_true
+  end
+
+  it 'should respond to save!' do
+    @test_instance.respond_to?(:save!).should be_true
+  end
+
+  it 'should respond to valid?' do
+    @test_instance.respond_to?(:valid?).should be_true
+  end
+
+  it 'should have id attribute' do
+    @test_instance.respond_to?(:id).should be_true
+  end
+
+  it 'should have created_at attribute' do
+    @test_instance.respond_to?(:created_at).should be_true
+  end
+
+  it 'should have command attributes' do
+    @test_instance.respond_to?(:command).should be_true
+    @test_instance.respond_to?(:command=).should be_true
+    @test_instance.respond_to?(:command_id).should be_true
+    @test_instance.respond_to?(:command_id=).should be_true
+  end
+
+  it 'should respond to to_json' do
+    @test_instance.respond_to?(:to_json).should be_true
+  end
+
+  it 'json should have _id attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('_id').should be_true
+  end
+
+  it 'json should have _type attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('_type').should be_true
+  end
+
+  it 'json should have created_at attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('created_at').should be_true
+  end
+
+  it 'json should have command_id attribute' do
+    json_data = @test_instance.to_json
+    json_hash = JSON.parse json_data
+    json_hash.key?('command_id').should be_true
+  end
+end

data/spec/junkfood/ceb/bus_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'Ceb::Bus' do
+
+  it 'should acts_as_bus' do
+    class TestFoo
+      def initialize(valid)
+        @valid = valid
+      end
+      def valid?
+        @valid
+      end
+    end
+
+    # Test that we have the proper attributes and methods created with defaults.
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_bus :foo
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_foo).should be_true
+    controller_instance.respond_to?(:foo_executor).should be_true
+    controller_instance.respond_to?(:foo_executor=).should be_true
+    controller_instance.foo_executor.should be_kind_of(Proc)
+
+    # Now override the executor on the initialization
+    my_executor = mock('MyExecutor')
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_bus :foo, my_executor
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_foo).should be_true
+    controller_instance.respond_to?(:foo_executor).should be_true
+    controller_instance.respond_to?(:foo_executor=).should be_true
+    controller_instance.foo_executor.should eql(my_executor)
+
+    # Now test that we can override the executor, and that the
+    # bus creates and executes with an instane of the TestCommand
+    executor1 = mock('FooExecutor')
+    executor1.should_receive(:call).with(an_instance_of(TestFoo))
+    controller_instance.foo_executor = executor1
+    controller_instance.foo_executor.should eql(executor1)
+    controller_instance.send_foo 'test', true
+
+    # Now we make sure that the TestCommand is invalid, so the
+    # executor will not be called.
+    executor2 = mock('FooExecutor')
+    controller_instance.foo_executor = executor2
+    controller_instance.foo_executor.should eql(executor2)
+    controller_instance.send_foo 'test', false
+  end
+
+  it 'should acts_as_command_bus' do
+    class TestCommand
+      def initialize(valid)
+        @valid = valid
+      end
+      def valid?
+        @valid
+      end
+    end
+
+    # Test that we have the proper attributes and methods created
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_command_bus
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_command).should be_true
+    controller_instance.respond_to?(:command_executor).should be_true
+    controller_instance.respond_to?(:command_executor=).should be_true
+    controller_instance.command_executor.should be_kind_of(
+      Junkfood::Ceb::Executors::CommandExecutor)
+
+    # Test again that we have the proper attributes and methods created
+    my_executor = mock('MyExecutor')
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_command_bus my_executor
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_command).should be_true
+    controller_instance.respond_to?(:command_executor).should be_true
+    controller_instance.respond_to?(:command_executor=).should be_true
+    controller_instance.command_executor.should eql(my_executor)
+
+    # Now test that we can override the executor, and that the
+    # bus creates and executes with an instane of the TestCommand
+    executor1 = mock('CommandExecutor')
+    executor1.should_receive(:call).with(an_instance_of(TestCommand))
+    controller_instance.command_executor = executor1
+    controller_instance.command_executor.should eql(executor1)
+    controller_instance.send_command 'test', true
+
+    # Now we make sure that the TestCommand is invalid, so the
+    # executor will not be called.
+    executor2 = mock('CommandExecutor')
+    controller_instance.command_executor = executor2
+    controller_instance.command_executor.should eql(executor2)
+    controller_instance.send_command 'test', false
+  end
+
+  it 'should acts_as_event_bus' do
+    class TestEvent
+      def initialize(valid)
+        @valid = valid
+      end
+      def valid?
+        @valid
+      end
+    end
+
+    # Test that we have the proper attributes and methods created
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_event_bus
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_event).should be_true
+    controller_instance.respond_to?(:event_executor).should be_true
+    controller_instance.respond_to?(:event_executor=).should be_true
+    controller_instance.event_executor.should be_kind_of(
+      Junkfood::Ceb::Executors::EventExecutor)
+
+    # Test again that we have the proper attributes and methods created
+    my_executor = mock('MyExecutor')
+    controller_class = Class.new do
+      include Junkfood::Ceb::Bus
+      acts_as_event_bus my_executor
+    end
+    controller_instance = controller_class.new
+    controller_instance.respond_to?(:send_event).should be_true
+    controller_instance.respond_to?(:event_executor).should be_true
+    controller_instance.respond_to?(:event_executor=).should be_true
+    controller_instance.event_executor.should eql(my_executor)
+
+    # Now test that we can override the executor, and that the
+    # bus creates and executes with an instane of the TestEvent
+    executor1 = mock('EventExecutor')
+    executor1.should_receive(:call).with(an_instance_of(TestEvent))
+    controller_instance.event_executor = executor1
+    controller_instance.event_executor.should eql(executor1)
+    controller_instance.send_event 'test', true
+
+    # Now we make sure that the TestEvent is invalid, so the
+    # executor will not be called.
+    executor2 = mock('EventExecutor')
+    controller_instance.event_executor = executor2
+    controller_instance.event_executor.should eql(executor2)
+    controller_instance.send_event 'test', false
+  end
+end

data/spec/junkfood/ceb/executors/command_executor_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe 'Ceb::Executors::CommandExecutor' do
+  it 'should save and perform the command (and return results)' do
+    expected_result = 'arbitrary return values'
+    command = mock('MyCommand')
+    command.should_receive(:new_record?).once.and_return(true)
+    command.should_receive(:save!).once
+    command.should_receive(:perform).once.and_return(expected_result)
+    executor = ::Junkfood::Ceb::Executors::CommandExecutor.new
+    result = executor.call command
+    result.should eql(expected_result)
+  end
+
+  it 'should just perform the command (and return results) without saving' do
+    expected_result = 'arbitrary return values'
+    command = mock('MyCommand')
+    command.should_receive(:new_record?).once.and_return(false)
+    command.should_receive(:perform).once.and_return(expected_result)
+    executor = ::Junkfood::Ceb::Executors::CommandExecutor.new
+    result = executor.call command
+    result.should eql(expected_result)
+  end
+end

data/spec/junkfood/ceb/executors/delayed_job_command_executor_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe 'Ceb::Executors::DelayedJobCommandExecutor' do
+  it 'should just queue the command into delayed job'
+end

data/spec/junkfood/ceb/executors/event_executor_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe 'Ceb::Executors::EventExecutor' do
+  it 'should save event (new record)' do
+    event = mock('MyEvent')
+    event.should_receive(:new_record?).once.and_return(true)
+    event.should_receive(:save!).once
+    executor = ::Junkfood::Ceb::Executors::EventExecutor.new
+    executor.call event
+  end
+
+  it 'should not save event (not new record)' do
+    event = mock('Event')
+    event.should_receive(:new_record?).once.and_return(false)
+    executor = ::Junkfood::Ceb::Executors::EventExecutor.new
+    executor.call event
+  end
+end

data/spec/junkfood/one_time_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "OneTime" do
+
+  it 'should pass RFC 4226 Appendix D Test Values' do
+    # Validates the first 10 OTPs for the RFC's test HOTP key (in RFC4226).
+    key = '12345678901234567890'
+    expected_results = [
+      '755224',
+      '287082',
+      '359152',
+      '969429',
+      '338314',
+      '254676',
+      '287922',
+      '162583',
+      '399871',
+      '520489',
+    ] 
+    for x in 0..9
+      Junkfood::OneTime.hotp(key, x).should eql(expected_results[x])
+    end
+  end
+
+  it 'should bulk pass RFC 4226 Appendix D Test Values' do
+    # Validates the first 10 OTPs for the RFC's test HOTP key (in RFC4226).
+    key = '12345678901234567890'
+    expected_results = [
+      '755224',
+      '287082',
+      '359152',
+      '969429',
+      '338314',
+      '254676',
+      '287922',
+      '162583',
+      '399871',
+      '520489',
+    ] 
+    results = Junkfood::OneTime.hotp_multi(
+      key,
+      0...expected_results.size)
+    results.should eql(expected_results)
+  end
+
+  it 'should provide low level details about algorithm values' do
+    key = '12345678901234567890'
+    expected_results = [
+      ['755224', 1284755224, 'cc93cf18508d94934c64b65d8ba7667fb7cde4b0'],
+      ['287082', 1094287082, '75a48a19d4cbe100644e8ac1397eea747a2d33ab'],
+      ['359152', 137359152, '0bacb7fa082fef30782211938bc1c5e70416ff44'],
+      ['969429', 1726969429, '66c28227d03a2d5529262ff016a1e6ef76557ece'],
+      ['338314', 1640338314, 'a904c900a64b35909874b33e61c5938a8e15ed1c'],
+      ['254676', 868254676, 'a37e783d7b7233c083d4f62926c7a25f238d0316'],
+      ['287922', 1918287922, 'bc9cd28561042c83f219324d3c607256c03272ae'],
+      ['162583', 82162583, 'a4fb960c0bc06e1eabb804e5b397cdc4b45596fa'],
+      ['399871', 673399871, '1b3c89f65e6c9e883012052823443f048b4332db'],
+      ['520489', 645520489, '1637409809a679dc698207310c8c7fc07290d9e5']
+    ]
+    for counter in 0...(expected_results.size)
+      results = Junkfood::OneTime.hotp_raw(key, counter)
+      results.size.should eql(3)
+      # Our hmac digest is a binary string, but we want to convert it into
+      # readable hex strings that we have in this spec's expected results.
+      results[2] = results[2].unpack('H*').first
+      results.should eql(expected_results[counter])
+    end
+  end
+
+  it 'should start counter at 0' do
+    key = '12345678901234567890'
+    one_time = Junkfood::OneTime.new key
+    one_time.counter.should eql(0)
+  end
+
+  it 'otp method should generate values without advancing counter' do
+    key = '12345678901234567890'
+    one_time = Junkfood::OneTime.new key
+    first = one_time.otp
+    first.should eql('755224')
+    second = one_time.otp
+    second.should eql('755224')
+    one_time.counter.should eql(0)
+  end
+
+  it 'bulk otp method should generate values without advancing counter' do
+    key = '12345678901234567890'
+    one_time = Junkfood::OneTime.new key
+    first = one_time.otp :range => 2
+    first.should eql(['755224', '287082'])
+    one_time.counter.should eql(0)
+  end
+
+  it 'otp! method should advance counter' do
+    key = '12345678901234567890'
+    one_time = Junkfood::OneTime.new key
+    first = one_time.otp!
+    first.should eql('755224')
+    one_time.counter.should eql(1)
+    second = one_time.otp!
+    second.should eql('287082')
+    one_time.counter.should eql(2)
+  end
+
+  it 'bulk otp! method should advance counter' do
+    key = '12345678901234567890'
+    one_time = Junkfood::OneTime.new key
+    first = one_time.otp! :range => 2
+    first.should eql(['755224', '287082'])
+    one_time.counter.should eql(2)
+  end
+
+  it 'should generate counter from epoch for Time Based HOTP' do
+    # RFC:
+    # TOTP: Time-based One-time Password Algorithm
+
+    # Test time values taken from the TOTP RFC Draft 5, Appendix B
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 30).should eql(1)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1111111109,
+      :step_size => 30).should eql(37037036)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1111111111,
+      :step_size => 30).should eql(37037037)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1234567890,
+      :step_size => 30).should eql(41152263)
+    Junkfood::OneTime.epoch_counter(
+      :time => 2000000000,
+      :step_size => 30).should eql(66666666)
+
+    # Now using the implicit default step size
+    Junkfood::OneTime::DEFAULT_STEP_SIZE.should eql(30)
+    Junkfood::OneTime.epoch_counter(
+      :time => 59).should eql(1)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1111111109).should eql(37037036)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1111111111).should eql(37037037)
+    Junkfood::OneTime.epoch_counter(
+      :time => 1234567890).should eql(41152263)
+    Junkfood::OneTime.epoch_counter(
+      :time => 2000000000).should eql(66666666)
+
+    # Testing alternate step sizes
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 60).should eql(0)
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 15).should eql(3)
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 59).should eql(1)
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 1).should eql(59)
+    Junkfood::OneTime.epoch_counter(
+      :time => 59,
+      :step_size => 2).should eql(29)
+    Junkfood::OneTime.epoch_counter(
+      :time => 2000000000,
+      :step_size => 15).should eql(133333333)
+  end
+end

data/spec/junkfood/paperclip_string_io_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'PaperclipStringIO' do
+
+  it 'should be a subclass of StringIO' do
+    io = Junkfood::PaperclipStringIo.new ''
+    io.kind_of?(StringIO).should eql(true)
+  end
+
+  it 'should have the content_type attribute' do
+    io = Junkfood::PaperclipStringIo.new ''
+    io.respond_to? :content_type
+  end
+
+  it 'should have the original_filename attribute' do
+    io = Junkfood::PaperclipStringIo.new ''
+    io.respond_to? :original_filename
+  end
+
+  it 'should have default content_type attribute' do
+    io = Junkfood::PaperclipStringIo.new ''
+    io.content_type.should eql('application/octet-stream')
+  end
+
+  it 'should have default original_filename attribute' do
+    io = Junkfood::PaperclipStringIo.new ''
+    io.original_filename.should eql('unnamed')
+  end
+
+  it 'should be able to have overridden attributes' do
+    filename = 'test.png'
+    content_type = 'image/png'
+    io = Junkfood::PaperclipStringIo.new(
+      '',
+      :content_type => content_type,
+      :filename => filename)
+    io.content_type.should eql(content_type)
+    io.original_filename.should eql(filename)
+  end
+end

data/spec/junkfood/settings_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Settings' do
+
+  it 'should eventually be testable'
+
+end

data/spec/junkfood_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Junkfood" do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'junkfood'
+require 'rspec/core'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end