ccp 0.2.5 → 0.2.6

data/README.rdoc

@@ -271,7 +271,9 @@ This generates "tmp/stub.json", "tmp/mock.json".
 Once you got fixtures, call "test" method to test it.
 
     Cmd.test
+    # or
+    #     Cmd.execute(:fixture_test=>true)
 
 This automatically searchs fixtures when no fixture files are explicitly given.
-The search algorithm is as same as 'fixture_save'.
+This mechanism is as same as 'fixture_save'.
 

data/lib/ccp/commands/composite.rb

@@ -4,9 +4,8 @@ module Ccp
       def self.included(base)
         super
         base.class_eval do
-          extend ClassMethods
-          extend Executable::ClassMethods
-          include Fixturable
+          include Core
+          extend CommandManager
         end
       end
 
@@ -25,7 +24,7 @@ module Ccp
       ######################################################################
       ### Class Methods
 
-      module ClassMethods
+      module CommandManager
         include Resolvable
 
         def prepend_command(klass, *args, &block)

data/lib/ccp/commands/core.rb

@@ -1,14 +1,12 @@
 module Ccp
   module Commands
     module Core
-      include Receivable
-      include Commentable
-      include Executable
-
       def self.included(base)
         super
         base.class_eval do
-          extend ClassMethods
+          include Receivable
+          include Commentable
+          include Executable
           include Fixturable
         end
       end

data/lib/ccp/commands/executable.rb

@@ -3,17 +3,13 @@ module Ccp
     module Executable
       def self.included(base)
         base.class_eval do
-          extend ClassMethods
-        end
-      end
-
-      module ClassMethods
-        def execute(options = {})
-          c = new
-          c.receiver = options.delete(:receiver)
-          c.receiver.parse!(options)
-          c.receiver.execute(c)
-          return c
+          def self.execute(options = {})
+            c = new
+            c.receiver = options.delete(:receiver)
+            c.receiver.parse!(options)
+            c.receiver.execute(c)
+            return c
+          end
         end
       end
 

data/lib/ccp/commands/fixturable.rb

@@ -6,17 +6,9 @@ module Ccp
           include Ccp::Utils::Options
           dsl_accessor :fixture, options(:stub, :mock, :fail, :save, :keys, :dir, :kvs, :ext)
 
-          extend Testable
-        end
-      end
-
-      module Testable
-        def test(options = {})
-          c = new
-          c.receiver = options.delete(:receiver)
-          c.receiver.parse!(options)
-          c.receiver.test(c)
-          return c
+          def self.test(options = {})
+            execute({:fixture_test=>true}.merge(options))
+          end
         end
       end
     end

data/lib/ccp/persistent/loadable.rb

@@ -9,6 +9,7 @@ module Ccp::Persistent::Loadable
 
   private
     def load_kvs_lookup_by_filename(file)
+      return Ccp::Persistent::Dir if File.directory?(file.to_s)
       case file.to_s
       when %r{/$}    ; Ccp::Persistent::Dir
       when %r{\.tsv$}; Ccp::Persistent::Tsv

data/lib/ccp/receivers/fixtures.rb

@@ -8,10 +8,18 @@ module Ccp
           super
           observer.stop
           fixture_save(cmd, observer.read, observer.write)
+
+        elsif fixture_test?(cmd)
+          stub = fixture_versioned_for(cmd)["stub"].path
+          fixture_stub(cmd.class.stub || (stub.exist? ? stub : nil))
+          super
+          mock = fixture_versioned_for(cmd)["mock"].path
+          fixture_mock(cmd, cmd.class.mock || mock)
+
         else
-          fixture_stub(cmd)
+          fixture_stub(cmd.class.stub)
           super
-          fixture_mock(cmd)
+          fixture_mock(cmd, cmd.class.mock)
         end
       end
 
@@ -20,6 +28,7 @@ module Ccp
 
         # Schema
         self[:fixture_save]     = Object # Define schema explicitly to accept true|false|Proc
+        self[:fixture_test]     = Object # Define schema explicitly to accept true|false|Proc
         self[:fixture_keys]     = Object # Define schema explicitly to accept true|[String]
 
         # Values
@@ -27,6 +36,7 @@ module Ccp
         self[:fixture_kvs]      = :file
         self[:fixture_ext]      = :json
         self[:fixture_save]     = false
+        self[:fixture_test]     = false
         self[:fixture_keys]     = true
         self[:fixture_path_for] = default_fixture_path_for
       end
@@ -39,27 +49,16 @@ module Ccp
         super
       end
 
-      def test(cmd)
-        # set stub if exist
-        stub = fixture_versioned_for(cmd)["stub"].path
-        runtime_stubs[cmd] = stub if stub.exist?
-
-        # set mock
-        runtime_mocks[cmd] = fixture_versioned_for(cmd)["mock"].path
-
-        execute(cmd)
-      end
-
-      def fixture_stub(cmd)
-        path = cmd.class.stub || runtime_stubs[cmd] or return
+      def fixture_stub(path)
+        return unless path
         hash = Ccp::Persistent.load(path).read!
         data.merge!(hash)
       rescue Ccp::Persistent::NotFound => e
         raise Ccp::Fixtures::NotFound, e.to_s
       end
 
-      def fixture_mock(cmd)
-        path = cmd.class.mock || runtime_mocks[cmd] or return
+      def fixture_mock(cmd, path)
+        return unless path
         hash = Ccp::Persistent.load(path).read!
 
         hash.keys.each do |key|
@@ -126,6 +125,22 @@ module Ccp
         storage.save(mock, fixture_keys_filter(keys, mock.keys))
       end
 
+      def fixture_test?(cmd)
+        case (obj = self[:fixture_test])
+        when true  ; true
+        when false ; false
+        when String; cmd.class.name == obj
+        when Array ; ary = obj.map(&:to_s); name = cmd.class.name
+          return false if ary.blank?
+          return true  if ary.include?(name)
+          return false if ary.include?("!#{name}")
+          return true  if ary.size == ary.grep(/^!/).size
+          return false
+        when Proc  ; instance_exec(cmd, &obj).must(true,false) {raise ":fixture_test should return true|false"}
+        else; raise ":fixture_test is invalid: #{obj.class}"
+        end
+      end
+
       def fixture_keys_filter(acl, keys)
         case acl
         when true ; keys

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/spec/commands/composite_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Ccp::Commands::Composite do
   describe "(instance)" do
-    subject { Object.new.extend Ccp::Commands::Composite } 
+    subject { Program.new }
 
     # data container
     it { should respond_to(:data?) }

data/spec/commands/core_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Ccp::Commands::Core do
   describe "(accessor)" do
-    subject { Object.new.extend Ccp::Commands::Core } 
+    subject { Cmd1.new }
 
     # data container
     it { should respond_to(:data?) }

data/spec/commands/fixturable_test_composite_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe Ccp::Receivers::Fixtures do
+  before do
+    FileUtils.rm_rf("tmp/fixtures")
+    FileUtils.mkdir_p("tmp/fixtures")
+  end
+
+  class CRFC1
+    def execute
+      data[:a] = 1
+    end
+  end
+
+  class CRFC2
+    def execute
+      data[:b] = 2
+    end
+  end
+
+  class CRFCC
+    include Ccp::Commands::Composite
+    command CRFC1
+    command CRFC2
+  end
+
+  describe CRFCC do
+    describe ".test" do
+      it "should test CRFC1, CRFC2, CRFF in order" do
+        lambda {
+          CRFCC.test
+        }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc1/mock.json")
+
+        save_fixture("tmp/fixtures/crfc1/mock.json", "a"=>1)
+        lambda {
+          CRFCC.test
+        }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc2/mock.json")
+
+        save_fixture("tmp/fixtures/crfc2/mock.json", "b"=>2)
+        lambda {
+          CRFCC.test
+        }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfcc/mock.json")
+
+        save_fixture("tmp/fixtures/crfcc/mock.json", {})
+        lambda {
+          CRFCC.test
+        }.should_not raise_error
+      end
+
+      context "(:fixture_test=>'CRFC2')" do
+        it "should test only CRFC2" do
+          lambda {
+            CRFCC.test(:fixture_test=>'CRFC2')
+          }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc2/mock.json")
+        end
+      end
+    end
+
+    describe ".execute" do
+      context "(:fixture_test=>true)" do
+        it "should test CRFC1, CRFC2, CRFF in order" do
+          lambda {
+            CRFCC.execute(:fixture_test=>true)
+          }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc1/mock.json")
+
+          save_fixture("tmp/fixtures/crfc1/mock.json", "a"=>1)
+          lambda {
+            CRFCC.execute(:fixture_test=>true)
+          }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc2/mock.json")
+
+          save_fixture("tmp/fixtures/crfc2/mock.json", "b"=>2)
+          lambda {
+            CRFCC.execute(:fixture_test=>true)
+          }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfcc/mock.json")
+
+          save_fixture("tmp/fixtures/crfcc/mock.json", {})
+          lambda {
+            CRFCC.execute(:fixture_test=>true)
+          }.should_not raise_error
+        end
+      end
+
+      context "(:fixture_test=>'CRFC2')" do
+        it "should test only CRFC2" do
+          lambda {
+            CRFCC.execute(:fixture_test=>'CRFC2')
+          }.should raise_error(Ccp::Fixtures::NotFound, "tmp/fixtures/crfc2/mock.json")
+        end
+      end
+
+    end
+  end
+end

data/spec/examples/fixture_save_dir_and_test_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require 'fileutils'
+
+describe Ccp::Receivers::Fixtures do
+  before do
+    FileUtils.rm_rf("tmp")
+  end
+
+  module Example1
+    class LoadInts
+      include Ccp::Commands::Core
+      def execute
+        data[:ints] = [10,20,30]
+      end
+    end
+
+    class CalculateMean
+      include Ccp::Commands::Core
+      def before
+        data.check(:ints)
+      end
+
+      def execute
+        data[:mean] = data[:ints].sum / data[:ints].size
+      end
+    end
+
+    class Main < Ccp::Invokers::Base
+      command LoadInts
+      command CalculateMean
+    end
+  end
+
+  describe ".execute" do
+    context "(:fixture_save=>true, :fixture_kvs=>:dir, :fixture_ext=>:json)" do
+      before { @options = {:fixture_save=>true, :fixture_kvs=>:dir, :fixture_ext=>:json} }
+
+      it "should create stubs and mocks as dir" do
+        Example1::Main.execute(@options)
+
+        Pathname("tmp/fixtures/example1").should exist
+        Dir["tmp/**/*.json"].sort.should ==
+          ["tmp/fixtures/example1/calculate_mean/mock.json",
+           "tmp/fixtures/example1/calculate_mean/mock.json/mean.json",
+           "tmp/fixtures/example1/calculate_mean/stub.json",
+           "tmp/fixtures/example1/calculate_mean/stub.json/ints.json",
+           "tmp/fixtures/example1/load_ints/mock.json",
+           "tmp/fixtures/example1/load_ints/mock.json/ints.json",
+           "tmp/fixtures/example1/main/mock.json",
+           "tmp/fixtures/example1/main/mock.json/ints.json",
+           "tmp/fixtures/example1/main/mock.json/mean.json",
+           "tmp/fixtures/example1/main/stub.json",
+           "tmp/fixtures/example1/main/stub.json/ints.json"]
+      end
+
+      it "should pass all test" do
+        Example1::Main.execute(@options)
+        lambda {
+          Example1::Main.test
+        }.should_not raise_error
+      end
+
+      it "should pass partial test" do
+        Example1::Main.execute(@options)
+        lambda {
+          Example1::CalculateMean.test
+        }.should_not raise_error
+      end
+      
+      it "should raise Typed::NotDefined when partial stub file is deleted" do
+        Example1::Main.execute(@options)
+        Pathname("tmp/fixtures/example1/calculate_mean/stub.json/ints.json").unlink
+        lambda {
+          Example1::CalculateMean.test
+        }.should raise_error(Typed::NotDefined, /'ints' is not initialized/)
+      end
+    end
+  end
+end

data/spec/persistent/loadable_spec.rb

@@ -6,6 +6,8 @@ describe Ccp::Persistent do
   it { should respond_to("load") }
 
   describe ".load" do
+    before { FileUtils.rm_rf "tmp" }
+
     context "('tmp/foo.json')" do
       subject { Ccp::Persistent.load('tmp/foo.json') }
       its(:class)  { should == Ccp::Persistent::File }
@@ -27,6 +29,27 @@ describe Ccp::Persistent do
       its(:source) { should == 'tmp/foo.json' }
     end
 
+    context "(Pathname('tmp/foo.json) with existed directory')" do
+      before { FileUtils.mkdir_p("tmp/foo.json") }
+      subject { Ccp::Persistent.load(Pathname('tmp/foo.json')) }
+      its(:class)  { should == Ccp::Persistent::Dir }
+      its(:ext)    { should == "json" }
+      its(:source) { should == Pathname('tmp/foo.json') }
+    end
+
+    context "('tmp/foo.json with existed directory')" do
+      before { FileUtils.mkdir_p("tmp/foo.json") }
+      subject { Ccp::Persistent.load('tmp/foo.json') }
+      its(:class)  { should == Ccp::Persistent::Dir }
+      its(:ext)    { should == "json" }
+      its(:source) { should == 'tmp/foo.json' }
+
+      it "can read!" do
+        save_fixture("tmp/foo.json/a.json", 1)
+        subject.read!.should == {"a"=>1}
+      end
+    end
+
     context "('tmp/foo')" do
       it "should raise Ccp::Serializers::NotFound" do
         lambda {

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 2
-  - 5
-  version: 0.2.5
+  - 6
+  version: 0.2.6
 platform: ruby
 authors: 
 - maiha
@@ -145,7 +145,9 @@ files:
 - spec/commands/core_spec.rb
 - spec/commands/executable_spec.rb
 - spec/commands/fixturable_spec.rb
+- spec/commands/fixturable_test_composite_spec.rb
 - spec/commands/fixturable_test_spec.rb
+- spec/examples/fixture_save_dir_and_test_spec.rb
 - spec/fixtures/cmd1stub_mock/mock.json
 - spec/fixtures/stub/breadcrumbs.json
 - spec/invokers/base_spec.rb