couch_docs 1.2.1 → 1.3.0

data/spec/couch_docs/command_line_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe CouchDocs::CommandLine do
+  it "should be able to run a single instance of a command line" do
+    CouchDocs::CommandLine.
+      should_receive(:new).
+      with('foo', 'bar').
+      and_return(mock("Command Line").as_null_object)
+
+    CouchDocs::CommandLine.run('foo', 'bar')
+  end
+
+  it "should run the command line instance" do
+    command_line = mock("Command Line").as_null_object
+    command_line.
+      should_receive(:run)
+
+    CouchDocs::CommandLine.stub!(:new).and_return(command_line)
+
+    CouchDocs::CommandLine.run('foo', 'bar')
+  end
+
+  context "an instance that dumps a CouchDB database" do
+    it "should dump CouchDB documents from uri to dir when run" do
+      @it = CouchDocs::CommandLine.new(['dump', 'uri', 'dir'])
+
+      CouchDocs.
+        should_receive(:dump).
+        with("uri", "dir", nil)
+
+      @it.run
+    end
+
+    it "should be able to dump only design documents" do
+      @it = CouchDocs::CommandLine.new(['dump', 'uri', 'dir', '-d'])
+
+      CouchDocs.
+        should_receive(:dump).
+        with("uri", "dir", :design)
+
+      @it.run
+    end
+
+    it "should be able to dump only regular documents" do
+      @it = CouchDocs::CommandLine.new(['dump', 'uri', 'dir', '-D'])
+
+      CouchDocs.
+        should_receive(:dump).
+        with("uri", "dir", :doc)
+
+      @it.run
+    end
+
+    it "should be an initial add if everything is an add" do
+      @it = CouchDocs::CommandLine.new(['push', 'uri'])
+      args = [mock(:type => :added),
+              mock(:type => :added)]
+      @it.should be_initial_add(args)
+    end
+
+    it "should not be an initial add if something is not an add" do
+      @it = CouchDocs::CommandLine.new(['push', 'uri'])
+      args = [mock(:type => :foo),
+              mock(:type => :added)]
+      @it.should_not be_initial_add(args)
+    end
+
+    it "should be a design docs update if something changes in _design" do
+      @it = CouchDocs::CommandLine.new(['push', 'uri'])
+      args = [mock(:path => "foo"),
+              mock(:path => "_design")]
+      @it.should be_design_doc_update(args)
+    end
+
+    it "should know document updates" do
+      @it = CouchDocs::CommandLine.new(['push', 'uri'])
+      doc_update = mock(:path => "foo")
+      args = [doc_update,
+              mock(:path => "_design")]
+
+      @it.
+        documents(args).
+        should == [doc_update]
+    end
+
+
+    context "updates on the filesystem" do
+      before(:each) do
+        @args = mock("args")
+        @it = CouchDocs::CommandLine.new(%w(push uri dir))
+      end
+      it "should only update design docs if only local design docs have changed" do
+        CouchDocs.
+          should_receive(:put_dir)
+
+        @it.stub!(:initial_add?).and_return(true)
+        @it.directory_watcher_update(@args)
+      end
+      context "not an inital add" do
+        before(:each) do
+          @it.stub!(:initial_add?).and_return(false)
+          @it.stub!(:design_doc_update?).and_return(false)
+          @it.stub!(:documents).and_return([])
+          CouchDocs.stub!(:put_design_dir)
+        end
+        it "should update design docs if there are design document updates" do
+          CouchDocs.
+            should_receive(:put_design_dir)
+
+          @it.stub!(:design_doc_update?).and_return(true)
+          @it.directory_watcher_update(@args)
+        end
+        it "should update documents (if any)" do
+          file_mock = mock("File", :path => "/foo")
+          @it.stub!(:documents).and_return([file_mock])
+
+          CouchDocs.
+            should_receive(:put_file).
+            with("uri", "/foo")
+
+          @it.directory_watcher_update(@args)
+        end
+      end
+    end
+  end
+
+  context "pushing" do
+    before(:each) do
+      CouchDocs.stub!(:put_dir)
+
+      @dw = mock("Directory Watcher").as_null_object
+      DirectoryWatcher.stub!(:new).and_return(@dw)
+    end
+
+    it "should know watch" do
+      @it = CouchDocs::CommandLine.new(%w(push uri dir -w))
+      @it.options[:watch].should be_true
+    end
+
+    it "should run once normally" do
+      @dw.should_receive(:run_once)
+
+      @it = CouchDocs::CommandLine.new(%w(push uri dir))
+      @it.run
+    end
+
+    it "should start a watcher with -w" do
+      @dw.should_receive(:start)
+
+      @it = CouchDocs::CommandLine.new(%w(push uri dir -w))
+      @it.stub!(:active?).and_return(false)
+      @it.run
+    end
+  end
+
+  context "an instance that uploads to a CouchDB database" do
+    before(:each) do
+      @it = CouchDocs::CommandLine.new(['load', 'dir', 'uri'])
+    end
+
+    it "should load CouchDB documents from dir to uri when run" do
+      CouchDocs.
+        should_receive(:put_dir).
+        with("uri", "dir")
+
+      @it.run
+    end
+  end
+
+end

data/spec/couch_docs/design_directory_spec.rb

@@ -0,0 +1,197 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe CouchDocs::DesignDirectory do
+  it "should require a root directory for instantiation" do
+    lambda { CouchDocs::DesignDirectory.new }.
+      should raise_error
+
+    lambda { CouchDocs::DesignDirectory.new("foo") }.
+      should raise_error
+
+    lambda { CouchDocs::DesignDirectory.new("fixtures/_design")}.
+      should_not raise_error
+  end
+
+  it "should convert arrays into deep hashes" do
+    CouchDocs::DesignDirectory.
+      a_to_hash(%w{a b c d}).
+      should == {
+      'a' => {
+        'b' => {
+          'c' => 'd'
+        }
+      }
+    }
+  end
+
+  context "a valid directory" do
+    before(:each) do
+      @it = CouchDocs::DesignDirectory.new("fixtures/_design")
+    end
+
+    it "should list dirs, basename and contents of a js file" do
+      @it.expand_file("fixtures/_design/a/b/c.js").
+        should == ['a', 'b', 'c', 'function(doc) { return true; }']
+    end
+
+    it "should list dirs, basename and contents of a json file" do
+      @it.expand_file("fixtures/_design/a/e.json").
+        should == ['a', 'e', [{"one" => "2"}]]
+    end
+
+    it "should assemble all documents into a single docs structure" do
+      @it.to_hash['a'].
+        should == {
+          'b' => {
+            'c' => 'function(doc) { return true; }',
+            'd' => 'function(doc) { return true; }'
+          },
+          'e' => [{"one" => "2"}]
+        }
+    end
+
+    it "should process code macros when assembling" do
+      @it.to_hash['x'].
+        should == {
+          'z' =>
+           "// !begin code foo.js\n" +
+           "function foo () { return \"foo\"; }\n" +
+           "// !end code foo.js\n" +
+           "function bar () { return \"bar\"; }\n"
+      }
+    end
+
+    it "should ignore macro escape sequence when reading JSON" do
+      @it.to_hash['j'].
+        should == {'q' => ["!code foo.js"]}
+    end
+
+    it "should work with absolute !code paths"
+
+    it "should replace !code macros with the contents of the referenced file in lib" do
+      @it.stub!(:read_from_lib).and_return("awesome javascript")
+
+      @it.
+        process_code_macro(" // !code foo/bar.js ").
+        should =~ /awesome javascript/
+    end
+
+    it "should not affect normal lines when processing macros" do
+      @it.
+        process_code_macro(" var foo = 'bar'; ").
+        should == " var foo = 'bar'; "
+    end
+
+    it "should find files with relative paths in __lib" do
+      File.
+        should_receive(:read).
+        with("fixtures/_design/__lib/foo.js")
+
+      @it.read_from_lib("foo.js")
+    end
+
+  end
+
+  context "saving a JSON attribute" do
+    before(:each) do
+      @it = CouchDocs::DesignDirectory.new("/tmp")
+
+      FileUtils.stub!(:mkdir_p)
+      @file = mock("File").as_null_object
+      File.stub!(:new).and_return(@file)
+    end
+
+    it "should not mangle json valued attributes" do
+      @file.
+        should_receive(:write).
+        with(%{["bar","baz"]})
+
+      @it.save_js(nil, "_design/foo", { "foo" => ["bar","baz"] })
+    end
+
+    it "should save in a .json file" do
+      File.
+        should_receive(:new).
+        with("/tmp/_design/foo/foo.json", "w+").
+        and_return(@file)
+
+      @it.save_js(nil, "_design/foo", { "foo" => ["bar","baz"] })
+    end
+  end
+
+  context "saving a JS attribute" do
+    before(:each) do
+      @it = CouchDocs::DesignDirectory.new("/tmp")
+
+      FileUtils.stub!(:mkdir_p)
+      @file = mock("File").as_null_object
+      File.stub!(:new).and_return(@file)
+    end
+
+    it "should not store _id" do
+      File.
+        should_not_receive(:new).
+        with("/tmp/_design/foo/_id.js", "w+")
+
+      @it.save_js(nil, "_design/foo", { "_id" => "_design/foo"})
+    end
+
+    it "should create map the design document attribute to the filesystem" do
+      FileUtils.
+        should_receive(:mkdir_p).
+        with("/tmp/_design/foo")
+
+      @it.save_js("_design/foo", "bar", "json")
+    end
+
+    it "should store the attribute to the filesystem" do
+      File.
+        should_receive(:new).
+        with("/tmp/_design/foo/bar.js", "w+")
+
+      @it.save_js("_design/foo", "bar", "json")
+    end
+
+    it "should store hash values to the filesystem" do
+      File.
+        should_receive(:new).
+        with("/tmp/_design/foo/bar/baz.js", "w+")
+
+      @it.save_js("_design/foo", "bar", { "baz" => "json" })
+    end
+
+    it "should store the attribute to the filesystem" do
+      @file.
+        should_receive(:write).
+        with("json")
+
+      @it.save_js("_design/foo", "bar", "json")
+    end
+
+    it "should store the attributes with slashes to the filesystem" do
+      File.
+        should_receive(:new).
+        with("/tmp/_design/foo/bar%2Fbaz.js", "w+")
+
+      @it.save_js("_design/foo", "bar/baz", "json")
+    end
+
+    it "should strip lib code when dumping" do
+      js = <<_JS
+// !begin code foo.js
+function foo () { return 'foo'; }
+// !end code foo.js
+// !begin code bar.js
+function bar () { return 'bar'; }
+// !end code bar.js
+function baz () { return 'baz'; }
+_JS
+
+      @it.
+        remove_code_macros(js).
+        should == "// !code foo.js\n" +
+                  "// !code bar.js\n" +
+                  "function baz () { return 'baz'; }\n"
+    end
+  end
+end

data/spec/couch_docs/document_directory_spec.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe CouchDocs::DocumentDirectory do
+  it "should require a root directory for instantiation" do
+    lambda { CouchDocs::DocumentDirectory.new }.
+      should raise_error
+
+    lambda { CouchDocs::DocumentDirectory.new("foo") }.
+      should raise_error
+
+    lambda { CouchDocs::DocumentDirectory.new("fixtures")}.
+      should_not raise_error
+  end
+
+  context "a valid directory" do
+    before(:each) do
+      @it = CouchDocs::DocumentDirectory.new("fixtures")
+    end
+
+    it "should be able to iterate over the documents" do
+      everything = []
+      @it.each_document do |name, contents|
+        everything << [name, contents]
+      end
+      everything.
+        should include ['bar', {"bar" => "2"}]
+
+      everything.
+        should include ['foo', {"foo" => "1"}]
+    end
+
+    it "should be able to store a document" do
+      file = mock("File", :write => 42, :close => true)
+      File.
+        should_receive(:new).
+        with("fixtures/foo.json", "w+").
+        and_return(file)
+
+      @it.store_document({'_id' => 'foo'})
+    end
+
+    it "should be able to save a document as JSON" do
+      file = mock("File", :close => true)
+      File.stub!(:new).and_return(file)
+
+      file.should_receive(:write).with(%Q|{"_id":"foo"}|)
+
+      @it.store_document({'_id' => 'foo'})
+    end
+
+    context "pushing attachments to CouchDB" do
+      before(:each) do
+        @spacer_b64 = "R0lGODlhAQABAPcAAAAAAIAAAACAAICAAAAAgIAAgACAgICAgMDAwP8AAAD/AP//AAAA//8A/wD//////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMwAAZgAAmQAAzAAA/wAzAAAzMwAzZgAzmQAzzAAz/wBmAABmMwBmZgBmmQBmzABm/wCZAACZMwCZZgCZmQCZzACZ/wDMAADMMwDMZgDMmQDMzADM/wD/AAD/MwD/ZgD/mQD/zAD//zMAADMAMzMAZjMAmTMAzDMA/zMzADMzMzMzZjMzmTMzzDMz/zNmADNmMzNmZjNmmTNmzDNm/zOZADOZMzOZZjOZmTOZzDOZ/zPMADPMMzPMZjPMmTPMzDPM/zP/ADP/MzP/ZjP/mTP/zDP//2YAAGYAM2YAZmYAmWYAzGYA/2YzAGYzM2YzZmYzmWYzzGYz/2ZmAGZmM2ZmZmZmmWZmzGZm/2aZAGaZM2aZZmaZmWaZzGaZ/2bMAGbMM2bMZmbMmWbMzGbM/2b/AGb/M2b/Zmb/mWb/zGb//5kAAJkAM5kAZpkAmZkAzJkA/5kzAJkzM5kzZpkzmZkzzJkz/5lmAJlmM5lmZplmmZlmzJlm/5mZAJmZM5mZZpmZmZmZzJmZ/5nMAJnMM5nMZpnMmZnMzJnM/5n/AJn/M5n/Zpn/mZn/zJn//8wAAMwAM8wAZswAmcwAzMwA/8wzAMwzM8wzZswzmcwzzMwz/8xmAMxmM8xmZsxmmcxmzMxm/8yZAMyZM8yZZsyZmcyZzMyZ/8zMAMzMM8zMZszMmczMzMzM/8z/AMz/M8z/Zsz/mcz/zMz///8AAP8AM/8AZv8Amf8AzP8A//8zAP8zM/8zZv8zmf8zzP8z//9mAP9mM/9mZv9mmf9mzP9m//+ZAP+ZM/+ZZv+Zmf+ZzP+Z///MAP/MM//MZv/Mmf/MzP/M////AP//M///Zv//mf//zP///yH5BAEAABAALAAAAAABAAEAAAgEALkFBAA7"
+      end
+
+      it "should connect attachments by sub-directory name (foo.json => foo/)" do
+        @it.stub!(:mime_type)
+
+        everything = []
+        @it.each_document do |name, contents|
+          everything << [name, contents]
+        end
+
+        everything.
+          should include(['baz_with_attachments',
+                         {'baz' => '3',
+                            "_attachments" => { "spacer.gif" => {"data" => @spacer_b64} } }])
+      end
+      it "should mime 64 encode attachments" do
+        # covered above
+      end
+      it "should ignore non-file attachments" do
+        # covered above
+      end
+
+      context "infering mime type" do
+        before(:each) do
+          File.stub!(:read).and_return("asdf")
+          Base64.stub!(:encode64).and_return("asdf")
+        end
+
+        it "should guess gif mime type" do
+          @it.file_as_attachment("spacer.gif").
+            should == {
+            "data"         => "asdf",
+            "content_type" => "image/gif"
+          }
+        end
+
+        it "should guess jpeg mime type" do
+          @it.file_as_attachment("spacer.jpg").
+            should == {
+            "data"         => "asdf",
+            "content_type" => "image/jpeg"
+          }
+        end
+
+        it "should guess png mime type" do
+          @it.file_as_attachment("spacer.png").
+            should == {
+            "data"         => "asdf",
+            "content_type" => "image/png"
+          }
+        end
+
+        it "should default to no mime type" do
+          @it.file_as_attachment("spacer.foo").
+            should == {
+            "data"         => "asdf"
+          }
+        end
+      end
+
+      it "should give precedence to filesystem attachments" do
+        @it.stub!(:mime_type)
+
+        JSON.stub!(:parse).
+          and_return({ "baz" => "3",
+                       "_attachments" => {
+                         "spacer.gif" => "asdf",
+                         "baz.jpg" => "asdf"
+                       }
+                     })
+
+        everything = []
+        @it.each_document do |name, contents|
+          everything << [name, contents]
+        end
+
+        everything.
+          should include(['baz_with_attachments',
+                         {'baz' => '3',
+                            "_attachments" => { "spacer.gif" => {"data" => @spacer_b64}, "baz.jpg" => "asdf" } }])
+      end
+
+    end
+    context "dump attachments from CouchDB" do
+      before(:each) do
+        FileUtils.stub!(:mkdir_p)
+      end
+
+      it "should store attachments" do
+        file = mock("File").as_null_object
+        File.stub!(:new).and_return(file)
+
+        @it.
+          should_receive(:store_attachments).
+          with('foo', 'bar')
+
+        @it.store_document({'_id' => 'foo',
+                            '_attachments' => 'bar'})
+      end
+
+      context "storing attachments" do
+        before(:each) do
+          @attachments = { 'foo.txt' => { 'data' => 'attachment data' } }
+        end
+
+        it "should make a directory to hold the attachments" do
+          @it.
+            should_receive(:make_attachment_dir).
+            with('foo')
+
+          @it.stub!(:save_attachment)
+          @it.store_attachments('foo', @attachments)
+        end
+
+        it "should create a sub-directory with document ID" do
+          FileUtils.
+            should_receive(:mkdir_p).
+            with("fixtures/foo")
+
+          @it.stub!(:save_attachment)
+          @it.make_attachment_dir('foo')
+        end
+
+        it "should save attachments to the filesystem" do
+          @it.
+            should_receive(:save_attachment).
+            with('foo', 'foo.txt', 'attachment data')
+
+          @it.stub!(:save_attachment)
+          @it.store_attachments('foo', @attachments)
+        end
+
+        it "should dump with native encoding (non-mime64)" do
+          file = mock("File").as_null_object
+          File.stub!(:new).and_return(file)
+
+          file.
+            should_receive(:write)
+
+          @it.save_attachment('foo', 'foo.txt', 'ZGF0YQ==')
+        end
+      end
+
+      it "should not include the attachments attribute" do
+        file = mock("File", :close => true)
+        File.stub!(:new).and_return(file)
+
+        file.
+          should_receive(:write).
+          with('{"_id":"foo"}')
+
+        @it.stub!(:store_attachments)
+
+        @it.store_document({'_id' => 'foo',
+                            '_attachments' => 'foo'})
+      end
+    end
+  end
+end

data/spec/couch_docs/store_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe CouchDocs::Store do
+  it "should require a CouchDB URL Root for instantiation" do
+    lambda { CouchDocs::Store.new }.
+      should raise_error
+
+    lambda { CouchDocs::Store.new("uri") }.
+      should_not raise_error
+  end
+
+  context "a valid store" do
+    before(:each) do
+      @it = CouchDocs::Store.new("uri")
+
+      @hash = {
+        'a' => {
+          'b' => {
+            'c' => 'function(doc) { return true; }'
+          }
+        }
+      }
+    end
+
+    it "should be able to put a new document" do
+      CouchDocs::Store.
+        should_receive(:put).
+        with("uri", { })
+
+      CouchDocs::Store.put!("uri", { })
+    end
+
+    it "should delete existing docs if first put fails" do
+      CouchDocs::Store.
+        stub!(:put).
+        and_raise(RestClient::RequestFailed)
+
+      CouchDocs::Store.
+        should_receive(:delete_and_put).
+        with("uri", { })
+
+      CouchDocs::Store.put!("uri", { })
+    end
+
+    it "should be able to delete and put" do
+      CouchDocs::Store.
+        should_receive(:delete).
+        with("uri")
+
+      CouchDocs::Store.
+        should_receive(:put).
+        with("uri", { })
+
+      CouchDocs::Store.delete_and_put("uri", { })
+    end
+
+    it "should be able to load a hash into design docs" do
+      RestClient.
+        should_receive(:put).
+        with("uri/_design/a",
+             '{"b":{"c":"function(doc) { return true; }"}}',
+             :content_type => 'application/json')
+      @it.put_design_documents(@hash)
+    end
+
+    it "should be able to retrieve an existing document" do
+      RestClient.
+        stub!(:get).
+        and_return('{"_rev":"1234"}')
+
+      CouchDocs::Store.get("uri").should == { '_rev' => "1234" }
+    end
+
+    it "should be able to delete an existing document" do
+      CouchDocs::Store.stub!(:get).and_return({ '_rev' => '1234' })
+
+      RestClient.
+        should_receive(:delete).
+        with("uri?rev=1234")
+
+      CouchDocs::Store.delete("uri")
+    end
+
+    it "should be able to load each document" do
+      CouchDocs::Store.stub!(:get).
+        with("uri/_all_docs").
+        and_return({ "total_rows" => 2,
+                     "offset"     => 0,
+                     "rows"       => [{"id"=>"1", "value"=>{}, "key"=>"1"},
+                                      {"id"=>"2", "value"=>{}, "key"=>"2"}]})
+
+      CouchDocs::Store.stub!(:get).with("uri/1?attachments=true")
+      CouchDocs::Store.should_receive(:get).with("uri/2?attachments=true")
+
+      @it.each { }
+    end
+  end
+end