mongo_browser 0.2.0.rc2 → 0.2.5

data/spec/javascripts/runner.html

@@ -15,11 +15,11 @@
   <script type="text/javascript" src="/assets/app.js"></script>
 
   <!-- Load specs -->
-  <script type="text/javascript" src="/assets/templates.js"></script>
+  <script type="text/javascript" src="/assets/compiled_templates.js"></script>
   <script type="text/javascript" src="/_specs/spec.js"></script>
 
   <script type="text/javascript">
-    (function () {
+    (function() {
       var jasmineEnv = jasmine.getEnv();
       jasmineEnv.updateInterval = 1000;
 
@@ -27,14 +27,14 @@
 
       jasmineEnv.addReporter(trivialReporter);
 
-      jasmineEnv.specFilter = function (spec) {
+      jasmineEnv.specFilter = function(spec) {
         return trivialReporter.specFilter(spec);
       };
 
       var currentWindowOnload = window.onload;
 
-      window.onload = function () {
-        if (currentWindowOnload) {
+      window.onload = function() {
+        if(currentWindowOnload) {
           currentWindowOnload();
         }
         execJasmine();

data/spec/lib/api/collections_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe MongoBrowser::API::Collections do
+  include ApiExampleGroup
+
+  def app
+    described_class
+  end
+
+  describe "collections" do
+    let(:db_name) { "first_database" }
+
+    describe_endpoint :get, "/databases/:db_name/collections" do
+      it { should be_successful }
+
+      describe "returned collections" do
+        subject(:collections) { JSON.parse(response.body) }
+
+        it { should_not be_empty }
+        it("contains all collections") { expect(collections).to have(4).items }
+
+        describe "a collection" do
+          subject(:collection) { collections.find { |collection| collection["name"] == "first_collection" } }
+
+          it { should_not be_nil }
+          it("contains database name") { expect(collection["dbName"]).to eq("first_database") }
+          it("contains collection name") { expect(collection["name"]).to eq("first_collection") }
+          it("contains number of documents") { expect(collection["size"]).to eq(2) }
+        end
+      end
+    end
+
+    describe_endpoint :get, "/databases/:db_name/collections/:collection_name/stats" do
+      let(:collection_name) { "first_collection" }
+
+      it { should be_successful }
+
+      it "returns stats for the collection with the given name" do
+        stats = JSON.parse(response.body)
+        expect(stats).not_to be_empty
+      end
+    end
+
+    describe_endpoint :delete, "/databases/:db_name/collections/:collection_name" do
+      let(:collection_name) { "first_collection" }
+
+      before do
+        expect { do_request }.to \
+          change { server.database(db_name).collections.count }.by(-1)
+      end
+
+      it { should be_successful }
+
+      it "deletes a collection with the given name" do
+        data = JSON.parse(response.body)
+        expect(data["success"]).to be_true
+      end
+    end
+  end
+
+
+end

data/spec/lib/api/databases_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe MongoBrowser::API::Databases do
+  include ApiExampleGroup
+
+  def app
+    described_class
+  end
+
+  describe "databases" do
+    describe_endpoint :get, "/databases" do
+      it { should be_successful }
+
+      describe "returned databases" do
+        subject(:data) { JSON.parse(response.body) }
+
+        it { should_not be_empty }
+        it("contains all databases") { should have_at_least(3).items }
+
+        describe "a database" do
+          subject(:database) { data.find { |db| db["name"] == "first_database" } }
+
+          it { should_not be_nil }
+          it("contains name") { expect(database["name"]).to eq("first_database") }
+          it("contains number of collections") { expect(database["count"]).to eq(4) }
+        end
+      end
+    end
+
+    describe_endpoint :delete, "/databases/:db_name" do
+      let(:db_name) { "first_database" }
+
+      before do
+        expect { do_request }.to \
+          change { server.databases.count }.by(-1)
+      end
+
+      it { should be_successful }
+
+      it "deletes a database with the given name" do
+        data = JSON.parse(response.body)
+        expect(data["success"]).to be_true
+      end
+    end
+
+    describe_endpoint :get, "/databases/:db_name/stats" do
+      let(:db_name) { "first_database" }
+
+      it { should be_successful }
+
+      it "gets stats for the given database" do
+        stats = JSON.parse(response.body)
+        expect(stats).to_not be_empty
+      end
+    end
+  end
+
+end

data/spec/lib/api/documents_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+describe MongoBrowser::API::Documents do
+  include ApiExampleGroup
+
+  def app
+    described_class
+  end
+
+  describe "documents" do
+    let(:db_name) { "first_database" }
+    let(:collection_name) { "first_collection" }
+
+    describe "paged documents list" do
+      shared_examples :returned_documents do
+        it("contains all documents") do
+          expect(data["documents"]).not_to be_nil
+          expect(data["documents"]).to have_at_least(1).item
+        end
+
+        describe "a document" do
+          subject(:document) { data["documents"].first }
+
+          it { should_not be_nil }
+          it("contains id") { expect(document["id"]).to_not be_nil }
+          it("contains document data") { expect(document["data"]).to_not be_nil }
+        end
+      end
+
+      describe_endpoint :get, "/databases/:db_name/collections/:collection_name/documents" do
+        it { should be_successful }
+
+        describe "returned documents" do
+          subject(:data) { JSON.parse(response.body) }
+
+          it("contains the current page") { expect(data["page"]).to equal(1) }
+          it("contains size") { expect(data["size"]).to equal(2) }
+          it("contains total pages") { expect(data["totalPages"]).to equal(1) }
+
+          include_examples :returned_documents
+        end
+      end
+
+      describe "for a large set of documents" do
+        before { Fixtures.instance.load_documents! }
+        let(:collection_name) { "second_collection" }
+
+        describe_endpoint :get, "/databases/:db_name/collections/:collection_name/documents?page=:page" do
+          let(:page) { 3 }
+
+          it { should be_successful }
+
+          describe "returned documents" do
+            subject(:data) { JSON.parse(response.body) }
+
+            it("contains the current page") { expect(data["page"]).to equal(3) }
+            it("contains size") { expect(data["size"]).to equal(70) }
+            it("contains total pages") { expect(data["totalPages"]).to equal(3) }
+
+            include_examples :returned_documents
+          end
+
+          context "when the page number is invalid" do
+            let(:page) { "invalid" }
+
+            it { should_not be_successful }
+            it("responds with 403") { expect(response.status).to eq(403) }
+
+            it("should notify about invalid param") do
+              error = JSON.parse(response.body)["error"]
+              expect(error).not_to be_nil
+              expect(error).to eq("invalid parameter: page")
+            end
+          end
+        end
+      end
+    end
+
+    describe_endpoint :get, "/databases/:db_name/collections/:collection_name/documents/:id" do
+      let(:id) do
+        document = server.database(db_name).collection(collection_name).mongo_collection.find({}, limit: 1).first
+        document["_id"]
+      end
+
+      context "whe the document has been found" do
+        it { should be_successful }
+
+        it "returns the document" do
+          data = JSON.parse(response.body)
+          expect(data["id"]).to eq(id.to_s)
+          expect(data["dbName"]).to eq(db_name)
+          expect(data["collectionName"]).to eq(collection_name)
+        end
+      end
+
+      context "when the documents has not been found" do
+        before do
+          collection = server.database(db_name).collection(collection_name)
+          document = collection.find(id)
+          collection.remove!(document)
+        end
+
+        it { should_not be_successful }
+        its(:status) { should == 404 }
+
+        it("should notify about not found document") do
+          error = JSON.parse(response.body)["error"]
+          expect(error).not_to be_nil
+          expect(error).to eq("Document not found")
+        end
+      end
+    end
+
+    describe_endpoint :delete, "/databases/:db_name/collections/:collection_name/documents/:id" do
+      let(:id) do
+        document = server.database(db_name).collection(collection_name).mongo_collection.find({}, limit: 1).first
+        document["_id"]
+      end
+
+      before do
+        expect { do_request }.to \
+          change { server.database(db_name).collection(collection_name).size }.by(-1)
+      end
+
+      it { should be_successful }
+
+      it "deletes a document with the given id" do
+        data = JSON.parse(response.body)
+        expect(data["success"]).to be_true
+      end
+    end
+  end
+
+
+end

data/spec/lib/api/mongo_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe MongoBrowser::API::Mongo do
+  include ApiExampleGroup
+
+  def app
+    described_class
+  end
+
+  describe_endpoint :get, "/server_info" do
+    it { should be_successful }
+
+    it "returns info about the server" do
+      server_info = JSON.parse(response.body)
+      expect(server_info).to_not be_empty
+    end
+  end
+
+  describe_endpoint :get, "/version" do
+    it { should be_successful }
+
+    it "returns application version" do
+      data = JSON.parse(response.body)
+      expect(data["version"]).to eq(MongoBrowser::VERSION)
+    end
+  end
+end

data/spec/lib/cli_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "mongo_browser/cli"
+
+describe MongoBrowser::CLI do
+
+  describe "#start" do
+    let(:runner) { double("runer", run!: true) }
+    before { Thin::Runner.stub(:new).and_return(runner) }
+
+    it "starts the application" do
+      args = ["start", "--port=1234"]
+      MongoBrowser::CLI.start(args)
+
+      expect(Thin::Runner).to have_received(:new).with(kind_of(Array))
+      expect(runner).to have_received(:run!)
+    end
+  end
+
+end

data/spec/lib/entities_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe MongoBrowser::Entities::Database do
+  let(:database) { double }
+  subject(:database_entity) { described_class.new(database) }
+
+  it { should expose :name }
+  it { should expose :size }
+  it { should expose :count }
+end
+
+describe MongoBrowser::Entities::Collection do
+  let(:collection) { double }
+  subject(:database_entity) { described_class.new(collection) }
+
+  it { should expose :dbName }
+  it { should expose :name }
+  it { should expose :size }
+end
+
+describe MongoBrowser::Entities::Document do
+  let(:document) { double }
+  subject(:database_entity) { described_class.new(document) }
+
+  it { should expose :id }
+  it { should expose :dbName }
+  it { should expose :collectionName }
+  it { should expose :data }
+end
+
+describe MongoBrowser::Entities::PagedDocuments do
+  let(:pager) { double }
+  subject(:database_entity) { described_class.new(pager) }
+
+  it { should expose :page }
+  it { should expose :size }
+  it { should expose :totalPages }
+  it { should expose :documents }
+end

data/spec/lib/models/collection_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 
 describe MongoBrowser::Models::Collection do
-  let(:mongo_db_name) { "first_database" }
-  let(:mongo_collection_name) { "first_collection" }
+  let(:db_name) { "first_database" }
+  let(:collection_name) { "first_collection" }
 
   let(:server) { MongoBrowser::Models::Server.current }
 
   let(:mongo_collection) do
-    server.connection[mongo_db_name]
-        .collection(mongo_collection_name)
+    server.connection[db_name]
+        .collection(collection_name)
   end
 
   let(:collection) { described_class.new(mongo_collection) }
@@ -18,8 +18,8 @@ describe MongoBrowser::Models::Collection do
     collection.mongo_collection.should == mongo_collection
   end
 
-  its(:db_name) { should == mongo_db_name }
-  its(:name) { should == mongo_collection_name }
+  its(:db_name) { should == db_name }
+  its(:name) { should == collection_name }
   its(:size) { should == 2 }
 
   describe "#stats" do
@@ -32,7 +32,7 @@ describe MongoBrowser::Models::Collection do
   end
 
   describe "#drop!" do
-    let(:database) { server.database(mongo_db_name) }
+    let(:database) { server.database(db_name) }
 
     it "drops the collection" do
       collection.drop!
@@ -41,9 +41,15 @@ describe MongoBrowser::Models::Collection do
   end
 
   describe "#documents_with_pagination" do
-    it "returns a collection of documents"
+    subject { collection.documents_with_pagination }
 
-    it "returns a pager"
+    it { should be_an_instance_of(OpenStruct) }
+    its(:size) { should == 2 }
+    its(:page) { should == 1 }
+    its(:total_pages) { should == 1 }
+
+    its(:documents) { should be_an_instance_of(Array) }
+    its(:documents) { should have(2).items }
   end
 
   describe "#find" do
@@ -70,7 +76,7 @@ describe MongoBrowser::Models::Collection do
   end
 
   describe "#remove!" do
-    let(:document) { MongoBrowser::Models::Document.new(mongo_collection.find.first) }
+    let(:document) { MongoBrowser::Models::Document.new(db_name, collection_name, mongo_collection.find.first) }
 
     it "removes a document from the collection" do
       expect(collection.remove!(document)).to be_true

data/spec/lib/models/database_spec.rb

@@ -2,8 +2,8 @@ require "spec_helper"
 
 describe MongoBrowser::Models::Database do
   let(:connection) { MongoBrowser::Models::Server.current.connection }
-  let(:mongo_db_name) { "first_database" }
-  let(:mongo_db) { connection[mongo_db_name] }
+  let(:db_name) { "first_database" }
+  let(:mongo_db) { connection[db_name] }
 
   let(:database) { described_class.new(mongo_db) }
   subject { database }
@@ -12,8 +12,8 @@ describe MongoBrowser::Models::Database do
     database.mongo_db.should == mongo_db
   end
 
-  its(:id) { should == mongo_db_name }
-  its(:name) { should == mongo_db_name }
+  its(:id) { should == db_name }
+  its(:name) { should == db_name }
 
   its(:size) { should be_an_instance_of(Fixnum) }