ccp 0.2.0 → 0.2.1

data/README.rdoc

@@ -138,8 +138,11 @@ some fixture data for the 'data' object.
 Ccp can automatically generate fixture data for each commands.
 Pass :save_fixture option to 'execute' class method to enable it.
 
-  * save_fixture     : enable write fixture mode if true
-  * save_fixture_dir : set root dir of fixture (default: tmp/fixtures)
+  * fixture_save : set true if you want this feature
+  * fixture_dir  : set root dir of fixture (default: tmp/fixtures)
+  * fixture_kvs  : file structure: :file|:dir (default: :file)
+  * fixture_ext  : file format: :json|:yaml (default: :json)
+  * fixture_keys : save data only keys written in here
 
 In above example, we can kick it with data[:a] like this.
 
@@ -147,22 +150,21 @@ In above example, we can kick it with data[:a] like this.
 
 And if you want to geneate fixures for this command, just add :save_fixture.
 
-    TSFC.execute(:a => 1, :save_fixture => true)
+    TSFC.execute(:a => 1, :fixture_save => true)
 
 This will create following files.
 
   % tree tmp/fixtures
   tmp/fixtures
-  └── tsfc
-      ├── in.yaml
-      └── out.yaml
-  
+  +- tsfc
+      +- read.json
+      +- write.json
+
   1 directory, 2 files    
-  % cat tmp/fixtures/tsfc/*
-  --- 
-  :a: 1
-  --- 
-  :x: 10
+  % cat tmp/fixtures/tsfc/read.json
+  {"a":1}
+  % cat tmp/fixtures/tsfc/write.json
+  {"x":10}
 
 === Writing tests
 
@@ -170,8 +172,8 @@ Use them as stubs and expected data as you like.
 
   describe TSFC do
     it "should work" do
-      data     = YAML.load(Pathname("tmp/fixtures/tsfc/in.yaml").read{})
-      expected = YAML.load(Pathname("tmp/fixtures/tsfc/out.yaml").read{})
+      data     = JSON.load(Pathname("tmp/fixtures/tsfc/read.json").read{})
+      expected = JSON.load(Pathname("tmp/fixtures/tsfc/write.json").read{})
 
       cmd = TSFC.execute(data)
 
@@ -183,3 +185,61 @@ Use them as stubs and expected data as you like.
 
 This code is highly versatile.
 
+=== Filter commands
+
+  * fixture_save : specify command names (negations can be used as "!")
+
+For example, imagine composite commands like this.
+
+  Program
+    +- Cmd1
+    +- Cmd2
+    +- Cmd3
+
+In this case, 
+
+    Program.execute(:fixture_save => true)
+
+generates following files.
+
+  * tmp/fixtures/cmd1/*.json
+  * tmp/fixtures/cmd2/*.json
+  * tmp/fixtures/cmd3/*.json
+  * tmp/fixtures/program/*.json
+
+If you want fixture data only for cmd2, run this.
+
+    Program.execute(:fixture_save => ["Cmd2"])
+
+"!" is used for special syntax which means 'negations'.
+
+    Program.execute(:fixture_save => ["!Program"])
+
+will generates fixtures for cmd1,cmd2,cmd3 (in short "not program").
+
+=== Filter data
+
+  * fixture_keys : specify data key names (negations can be used as "!")
+
+For example, imagine a command like this.
+
+    class Cmd
+      def execute
+        data[:x] = 10
+        data[:logger].debug "x is set"
+      end
+    end
+
+This code will generate fixtures about 'x' and 'logger' cause it read those vars.
+In many case, we don't need 'logger' object for test data, and furthermore,
+the logger object would be failed in Json serialization.
+
+In this case, we want to filter save data. Try fixtures_keys!
+
+    Cmd.execute(:fixture_save => true, :fixture_keys => ['x'])
+
+This will generate "read.json" that contains only 'x'.
+And, "!" can be used for negations as same as "Filter commands".
+
+    Cmd.execute(:fixture_save => true, :fixture_keys => ['!logger'])
+

data/ccp.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "typed", ">= 0.2.1"
+  s.add_dependency "typed", ">= 0.2.2"
   s.add_dependency "must", ">= 0.2.7"
   s.add_dependency "dsl_accessor", ">= 0.4.0"
 

data/lib/ccp/invokers/base.rb

@@ -10,6 +10,9 @@ module Ccp
       dsl_accessor :comment , true
       dsl_accessor :logger  , proc{ Logger.new($stderr) }
 
+      dsl_accessor :builtin_options, :default => {:profile => profile, :comment => comment, :logger => logger}
+      dsl_accessor :default_options, :default => {}
+
       ######################################################################
       ### Class Methods
 
@@ -20,17 +23,15 @@ module Ccp
         return cmd
       end
 
-      def self.default_options
-        {:profile => profile, :comment => comment, :logger => logger}
-      end
-
       ######################################################################
       ### Instance Methods
 
       def initialize(options = {})
         self.receiver = options.delete(:receiver) || self.class.receiver.new
+        receiver.parse!(:fixture_keys => self.class.builtin_options.keys.map{|i| "!#{i}"})
+        receiver.parse!(options)
+        receiver.data.default.merge!(self.class.builtin_options)
         receiver.data.default.merge!(self.class.default_options)
-        receiver.data.merge!(options)
       end
 
       def after

data/lib/ccp/persistent/base.rb

@@ -19,8 +19,8 @@ class Ccp::Persistent::Base
     raise NotImplementedError, "subclass resposibility"
   end
 
-  def save(hash)
-    hash.keys.each do |key|
+  def save(hash, keys = nil)
+    (keys || hash.keys).each do |key|
       self[key] = hash[key]
     end
   end

data/lib/ccp/receivers/fixtures.rb

@@ -18,26 +18,30 @@ module Ccp
       end
 
       def execute(cmd)
-        return super unless fixtures_save?(cmd)
+        return super unless fixture_save?(cmd)
 
         observer = Ccp::Fixtures::Observer.new(data)
         observer.start
         super
         observer.stop
 
-        fixtures_save(cmd, observer.read, observer.write)
+        fixture_save(cmd, observer.read, observer.write)
       end
 
       def setup
         super
 
-        self[:fixture_save]     = Object # Schema
+        # Schema
+        self[:fixture_save]     = Object # Define schema explicitly to accept true|false|Proc
+        self[:fixture_keys]     = Object # Define schema explicitly to accept true|[String]
 
+        # Values
         self[:fixture_dir]      = "tmp/fixtures"
         self[:fixture_kvs]      = :file
         self[:fixture_ext]      = :json
-        self[:fixture_save]     = proc{|cmd| false }
-        self[:fixture_path_for] = proc{|cmd| settings.path(:fixture_dir) + cmd.class.name.underscore}
+        self[:fixture_save]     = false
+        self[:fixture_keys]     = true
+        self[:fixture_path_for] = default_fixture_path_for
       end
 
       def parse!(options)
@@ -48,28 +52,56 @@ module Ccp
         super
       end
 
-      def fixtures_save?(cmd)
+      def fixture_save?(cmd)
         case (obj = self[:fixture_save])
-        when true ; obj
-        when false; obj
-        when Proc; obj.call(cmd)
+        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_save should return true|false"}
         else; raise ":fixture_save is invalid: #{obj.class}"
         end
       end
 
-      def fixtures_save(cmd, read, write)
+      def fixture_save(cmd, read, write)
         path      = self[:fixture_path_for].call(cmd)
         versioned = Ccp::Persistent::Versioned.new(path, :kvs=>self[:fixture_kvs], :ext=>self[:fixture_ext])
-        versioned["read" ].save(read)
-        versioned["write"].save(write)
+        versioned["read" ].save(read , fixture_keys_filter(read.keys))
+        versioned["write"].save(write, fixture_keys_filter(write.keys))
       end
 
-      def fixtures_for(cmd, key)
+      def fixture_keys_filter(keys)
+        case (obj = self[:fixture_keys])
+        when true ; keys
+        when false; []
+        when Array
+          ary = obj.map(&:to_s)
+          return keys if ary == []
+          if ary.size == ary.grep(/^!/).size
+            return keys.dup.reject{|v| ary.include?("!#{v}")}
+          else
+            ary & keys
+          end
+        else
+          raise ":fixture_keys is invalid: #{obj.class}"
+        end
+      end
+
+      def fixture_for(cmd, key)
         kvs  = Ccp::Persistent.lookup(self[:fixture_kvs])
         code = Ccp::Serializers.lookup(self[:fixture_ext])
-        path = self[:fixture_path_for].call(cmd) + "#{key}.#{code.ext}.#{kvs.ext}"
+        path = instance_exec(cmd, &self[:fixture_path_for]) + "#{key}.#{code.ext}.#{kvs.ext}"
         return Storage.new(kvs.new(path, code))
       end
+
+      def default_fixture_path_for
+        proc{|cmd| settings.path(:fixture_dir) + cmd.class.name.underscore}
+      end
     end
   end
 end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/invokers/save_fixture_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require 'fileutils'
+
+describe Ccp::Invokers::Base do
+  def load(path)
+    case path.extname
+    when ".json"; JSON.load(Pathname(path).read{})
+    when ".yaml"; YAML.load(Pathname(path).read{})
+    else; raise "load doesn't support #{path.extname}"
+    end
+  end
+
+  describe ".execute" do
+    before do
+      FileUtils.rm_rf("tmp")
+    end
+
+    context "(:fixture_save=>true)" do
+      it "should generate read/write fixtures in tmp/fixtures as json files" do
+        path = Pathname("tmp/fixtures")
+        data = {:breadcrumbs => []}
+        opts = {:fixture_save=>true}
+
+        CompositeInvoker.execute(data.merge(opts))
+
+        (read = path + "composite_invoker/read.json" ).should exist
+        load(read)["breadcrumbs"].should == 
+          ["CompositeInvoker#before",
+           "Cmd1#before", "Cmd1#execute", "Cmd1#after",
+           "Cmd23#before",
+           "Cmd23#execute:start",
+           "Cmd2#before", "Cmd2#execute", "Cmd2#after",
+           "Cmd3#before", "Cmd3#execute", "Cmd3#after",
+           "Cmd23#execute:end",
+           "Cmd23#after",
+           "Cmd4#before", "Cmd4#execute", "Cmd4#after",
+           "CompositeInvoker#after"]
+      end
+    end
+  end
+end

data/spec/models.rb

@@ -97,3 +97,12 @@ class CompositeInvoker < Ccp::Invokers::Base
     super
   end
 end
+
+class TSFC                  # TestSaveFixtureCmd
+  include Ccp::Commands::Core
+
+  def execute
+    data[:a]                # read
+    data[:x] = 10           # write
+  end
+end

data/spec/receivers/fixture_save_how_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require 'fileutils'
+
+describe "Ccp::Commands::Core" do
+  describe ".execute" do
+    before do
+      FileUtils.rm_rf("tmp")
+    end
+
+    context "(:fixture_save=>true)" do
+      it "should generate read/write fixtures in tmp/fixtures as json files" do
+        path = Pathname("tmp/fixtures")
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true}
+
+        TSFC.execute(data.merge(opts))
+
+        load_fixture(path + "tsfc/read.json" ).should == {"a" => "a"}
+        load_fixture(path + "tsfc/write.json").should == {"x" => 10}
+      end
+    end
+
+    context "(:fixture_save=>true, :fixture_ext=>:yaml)" do
+      it "should generate read/write fixtures in tmp/fixtures as yaml files" do
+        path = Pathname("tmp/fixtures")
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true, :fixture_ext=>:yaml}
+
+        TSFC.execute(data.merge(opts))
+
+        load_fixture(path + "tsfc/read.yaml" ).should == {"a" => "a"}
+        load_fixture(path + "tsfc/write.yaml").should == {"x" => 10}
+      end
+    end
+
+    context "(:fixture_save=>true, :fixture_kvs=>:dir)" do
+      it "should generate json files in read/write dir" do
+        path = Pathname("tmp/fixtures")
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true, :fixture_kvs=>:dir}
+
+        TSFC.execute(data.merge(opts))
+
+        load_fixture(path + "tsfc/read.json/a.json" ).should == "a"
+        load_fixture(path + "tsfc/write.json/x.json").should == 10
+      end
+    end
+  end
+end

data/spec/receivers/fixture_save_ignore_logger_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require 'fileutils'
+
+describe Ccp::Invokers::Base do
+  before do
+    FileUtils.rm_rf("tmp")
+  end
+
+  class ULI < Ccp::Invokers::Base # UsingLoggerInvoker
+    def execute
+      data[:a]
+      data[:logger]
+
+      data[:x] = 10
+      data[:logger] = Logger.new("/dev/null")
+    end
+  end
+
+  describe ".execute" do
+    context "(:fixture_save=>true)" do
+      it "should ignore :logger in default" do
+        ULI.execute(:a=>"a", :fixture_save=>true)
+
+        load_fixture("tmp/fixtures/uli/read.json" ).should == {"a" => "a"}
+        load_fixture("tmp/fixtures/uli/write.json" ).should == {"x" => 10}
+      end
+    end
+  end
+end

data/spec/receivers/fixture_save_what_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+require 'fileutils'
+
+######################################################################
+### What means targets
+
+describe Cmd1 do
+  describe ".execute" do
+    FIXTURE_PATH = Pathname("tmp/fixtures/cmd1")
+
+    before do
+      FileUtils.rm_rf(FIXTURE_PATH.to_s)
+    end
+
+    def created_keys
+      load_fixture(FIXTURE_PATH + "read.json").keys.sort
+    rescue Errno::ENOENT
+      []
+    end
+
+    def self.execute(opts = {}, &block)
+      context "(#{opts.inspect})" do
+        expected = block.call
+        it "should create #{expected.inspect}" do
+          Cmd1.execute({:breadcrumbs=>[]}.merge(opts))
+          created_keys.should == expected
+        end
+      end
+    end
+
+    ######################################################################
+    ### fixture_save
+
+    # nop when :save is not given
+    execute() do
+      []
+    end
+
+    execute(:fixture_save => true) do
+      ["breadcrumbs"]
+    end
+
+    ######################################################################
+    ### accepts
+
+    execute(:fixture_save => true, :fixture_keys => true) do
+      ["breadcrumbs"]
+    end
+
+    execute(:fixture_save => true, :fixture_keys => ['x']) do
+      []
+    end
+
+    ######################################################################
+    ### excepts
+
+    execute(:fixture_save => true, :fixture_keys => ['!breadcrumbs']) do
+      []
+    end
+
+    execute(:fixture_save => true, :fixture_keys => ['!breadcrumbsXXX']) do
+      ["breadcrumbs"]
+    end
+
+    ######################################################################
+    ### accepts & excepts
+
+    execute(:fixture_save => true, :fixture_keys => ['xxx', '!breadcrumbs']) do
+      []
+    end
+
+    execute(:fixture_save => true, :fixture_keys => ['xxx', '!xxx']) do
+      []
+    end
+
+    execute(:fixture_save => true, :fixture_keys => ['breadcrumbs', '!xxx']) do
+      ["breadcrumbs"]
+    end
+
+    execute(:fixture_save => true, :fixture_keys => ['breadcrumbs', '!breadcrumbs']) do
+      ["breadcrumbs"]
+    end
+  end
+end

data/spec/receivers/fixture_save_where_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require 'fileutils'
+
+describe "Ccp::Commands::Core" do
+  describe ".execute" do
+    before do
+      FileUtils.rm_rf("tmp")
+    end
+
+    context "(:fixture_save=>true, :fixture_dir=>...)" do
+      it "should generate read/write fixtures in <save_fixture_dir> as json files" do
+        path = Pathname("tmp/test/fixtures")
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true, :fixture_dir=>path.to_s}
+
+        TSFC.execute(data.merge(opts))
+
+        load_fixture(path + "tsfc/read.json" ).should == {"a" => "a"}
+        load_fixture(path + "tsfc/write.json").should == {"x" => 10}
+      end
+    end
+  end
+end

data/spec/receivers/fixture_save_why_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require 'fileutils'
+
+######################################################################
+### Why means ACL
+
+describe Ccp::Commands::Composite do
+  describe ".execute" do
+    FIXTURE_ROOT = "tmp/fixtures"
+
+    before do
+      FileUtils.rm_rf(FIXTURE_ROOT.to_s)
+    end
+
+    def created_fixtures
+      Dir.chdir(FIXTURE_ROOT){Dir["*/read.json"].map{|i| File.dirname(i)}.sort}
+    rescue Errno::ENOENT
+      []
+    end
+
+    def self.execute(opts = {}, &block)
+      context "(#{opts.inspect})" do
+        expected = block.call
+        it "should create #{expected.inspect}" do
+          Program.execute({:breadcrumbs=>[]}.merge(opts))
+          created_fixtures.should == expected
+        end
+      end
+    end
+
+    ######################################################################
+    ### fixture_save
+
+    # nop when :save is not given
+    execute() do
+      []
+    end
+
+    # nop when :save is false
+    execute(:fixture_save => false) do
+      []
+    end
+
+    execute(:fixture_save => true) do
+      ["cmd1", "cmd2", "cmd3", "program"]
+    end
+
+    ######################################################################
+    ### accepts
+
+    execute(:fixture_save => 'Cmd2') do
+      ["cmd2"]
+    end
+
+    execute(:fixture_save => ['Cmd2']) do
+      ["cmd2"]
+    end
+
+    execute(:fixture_save => ['Cmd2', 'Cmd3']) do
+      ["cmd2", "cmd3"]
+    end
+
+    # no match
+    execute(:fixture_save => ['CmdX']) do
+      []
+    end
+
+    ######################################################################
+    ### excepts
+
+    execute(:fixture_save => ['!Cmd1']) do
+      ["cmd2", "cmd3", "program"]
+    end
+
+    execute(:fixture_save => ['!Cmd2', '!Program']) do
+      ["cmd1", "cmd3"]
+    end
+
+    ######################################################################
+    ### accepts & excepts
+
+    # :accept has a higher priority
+    execute(:fixture_save => ['Cmd1','!Cmd2']) do
+      ['cmd1']
+    end
+
+    # :accept is used even if settings are conflicted
+    execute(:fixture_save => ['Cmd1','!Cmd1']) do
+      ['cmd1']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -12,3 +12,11 @@ def breadcrumbs_receiver
   return r
 end
 
+def load_fixture(path)
+  path = Pathname(path)
+  case path.extname
+  when ".json"; JSON.load(Pathname(path).read{})
+  when ".yaml"; YAML.load(Pathname(path).read{})
+  else; raise "load doesn't support #{path.extname}"
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-02 00:00:00 +09:00
+date: 2012-05-07 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 21
+        hash: 19
         segments: 
         - 0
         - 2
-        - 1
-        version: 0.2.1
+        - 2
+        version: 0.2.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -140,13 +140,18 @@ files:
 - spec/commands/core_spec.rb
 - spec/commands/executable_spec.rb
 - spec/invokers/base_spec.rb
+- spec/invokers/save_fixture_spec.rb
 - spec/models.rb
 - spec/persistent/base_spec.rb
 - spec/persistent/dir_spec.rb
 - spec/persistent/file_spec.rb
 - spec/persistent/tsv_spec.rb
 - spec/persistent/versioned_spec.rb
-- spec/receivers/fixture_save_spec.rb
+- spec/receivers/fixture_save_how_spec.rb
+- spec/receivers/fixture_save_ignore_logger_spec.rb
+- spec/receivers/fixture_save_what_spec.rb
+- spec/receivers/fixture_save_where_spec.rb
+- spec/receivers/fixture_save_why_spec.rb
 - spec/serializers/core_spec.rb
 - spec/serializers/json_spec.rb
 - spec/serializers/spec.rb

data/spec/receivers/fixture_save_spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-require 'fileutils'
-
-describe Ccp::Receivers::Fixtures do
-  class TSFC                  # TestSaveFixtureCmd
-    include Ccp::Commands::Core
-
-    def execute
-      data[:a]                # read
-      data[:x] = 10           # write
-    end
-  end
-
-  def load(path)
-    case path.extname
-    when ".json"; JSON.load(Pathname(path).read{})
-    when ".yaml"; YAML.load(Pathname(path).read{})
-    else; raise "load doesn't support #{path.extname}"
-    end
-  end
-
-  describe ".execute" do
-    before do
-      FileUtils.rm_rf("tmp")
-    end
-
-    context "(:fixture_save=>true)" do
-      it "should generate read/write fixtures in tmp/fixtures as json files" do
-        path = Pathname("tmp/fixtures")
-        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
-        opts = {:fixture_save=>true}
-
-        TSFC.execute(data.merge(opts))
-
-        load(path + "tsfc/read.json" ).should == {"a" => "a"}
-        load(path + "tsfc/write.json").should == {"x" => 10}
-      end
-    end
-
-    context "(:fixture_save=>true, :fixture_ext=>:yaml)" do
-      it "should generate read/write fixtures in tmp/fixtures as yaml files" do
-        path = Pathname("tmp/fixtures")
-        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
-        opts = {:fixture_save=>true, :fixture_ext=>:yaml}
-
-        TSFC.execute(data.merge(opts))
-
-        load(path + "tsfc/read.yaml" ).should == {"a" => "a"}
-        load(path + "tsfc/write.yaml").should == {"x" => 10}
-      end
-    end
-
-    context "(:fixture_save=>true, :fixture_dir=>...)" do
-      it "should generate read/write fixtures in <save_fixture_dir> as json files" do
-        path = Pathname("tmp/test/fixtures")
-        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
-        opts = {:fixture_save=>true, :fixture_dir=>path.to_s}
-
-        TSFC.execute(data.merge(opts))
-
-        load(path + "tsfc/read.json" ).should == {"a" => "a"}
-        load(path + "tsfc/write.json").should == {"x" => 10}
-      end
-    end
-
-    context "(:fixture_save=>true, :fixture_kvs=>:dir)" do
-      it "should generate json files in read/write dir" do
-        path = Pathname("tmp/fixtures")
-        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
-        opts = {:fixture_save=>true, :fixture_kvs=>:dir}
-
-        TSFC.execute(data.merge(opts))
-
-        load(path + "tsfc/read.json/a.json" ).should == "a"
-        load(path + "tsfc/write.json/x.json").should == 10
-      end
-    end
-  end
-end