mongo_browser 0.2.0.rc2 → 0.2.5

data/spec/javascripts/app/modules/dialogs_spec.js.coffee

@@ -22,8 +22,7 @@ describe "mb.dialogs", ->
       confirmationDialog(message: "This is a test message")
 
       # Then
-      expect(dialogsHandler.confirm).toHaveBeenCalledWith \
-        "This is a test message",
+      expect(dialogsHandler.confirm).toHaveBeenCalledWith "This is a test message",
         jasmine.any(Function)
 
     describe "when the dialog was confirmed", ->

data/spec/javascripts/app/modules/pager_spec.js.coffee

@@ -14,7 +14,6 @@ describe "mb.pager", ->
       expect(p.outerWindow).toEqual(0)
 
     describe "windowedPageNumbers", ->
-
       it "calculates windowed visible links", inject (pager) ->
         prepare = pager(page: 6, totalPages: 11, innerWindow: 1, outerWindow: 1)
         expect(prepare.windowedPageNumbers()).toEqual [1, 2, null, 5, 6, 7, null, 10, 11]

data/spec/javascripts/app/modules/spinner_spec.js.coffee

@@ -0,0 +1,65 @@
+describe "mb.spinner", ->
+  beforeEach module("mb.spinner")
+
+  describe "httpRequestTracker", ->
+    $http = null
+    httpRequestTracker = null
+
+    beforeEach inject ($injector) ->
+      httpRequestTracker = $injector.get("httpRequestTracker")
+      $http = $injector.get("$http")
+
+    describe "when no requests is progress", ->
+      it "does not report pending requests", ->
+        expect(httpRequestTracker.hasPendingRequests()).toBeFalsy()
+
+    describe "when requests are in progress", ->
+      beforeEach -> $http.pendingRequests.push({})
+
+      it "reports pending requests", ->
+        expect(httpRequestTracker.hasPendingRequests()).toBeTruthy()
+
+  describe "controller", ->
+    httpRequestTracker = null
+    controller = null
+    $scope = null
+
+    beforeEach inject ($injector, $rootScope, $controller) ->
+      httpRequestTracker = $injector.get("httpRequestTracker")
+      $scope = $rootScope.$new()
+      controller = $controller "spinner",
+        $scope: $scope
+
+    describe "#showSpinner", ->
+      describe "when there is a pending request", ->
+        beforeEach ->
+          spyOn(httpRequestTracker, "hasPendingRequests").andReturn(true)
+
+        it "returns true", ->
+          expect($scope.showSpinner()).toBeTruthy()
+
+      describe "otherwise", ->
+        beforeEach ->
+          spyOn(httpRequestTracker, "hasPendingRequests").andReturn(false)
+
+        it "returns false", ->
+          expect($scope.showSpinner()).toBeFalsy()
+
+  describe "directive", ->
+    element = null
+
+    beforeEach inject ($compile, $rootScope) ->
+      $scope = $rootScope
+      $scope.showSpinner = -> false
+
+      element = angular.element """
+      <spinner></spinner>
+      """
+      $compile(element)($scope)
+      $scope.$digest()
+
+    it "renders the spinner", ->
+      img = element.find("img")
+
+      expect(img.length).toBe(1)
+      expect(img.attr("src")).toEqual("/assets/ajax-loader.gif")

data/spec/javascripts/app/modules/table_filter_spec.js.coffee

@@ -1,7 +1,7 @@
 describe "mb.tableFilter", ->
   beforeEach module("mb.tableFilter")
 
-  describe "tableFilter controller", ->
+  describe "controller", ->
     $scope = null
 
     beforeEach inject ($controller, $rootScope) ->
@@ -25,21 +25,21 @@ describe "mb.tableFilter", ->
 
         expect($scope.value).toEqual("")
 
-  describe "tableFilter", ->
+  describe "directive", ->
     $scope = null
     element = null
 
-    beforeEach module("app/assets/templates/table_filter.html")
+    beforeEach module("public/ng/templates/table_filter.html")
 
     beforeEach inject ($rootScope, $compile) ->
       $scope = $rootScope
 
-      tpl = """
-            <div>
-              <table-filter value="filterValue" placeholder="Enter database name"></table-filter>
-            </div>
-            """
-      element = $compile(tpl)($scope)
+      element = angular.element """
+      <div>
+        <table-filter value="filterValue" placeholder="Enter database name"></table-filter>
+      </div>
+      """
+      $compile(element)($scope)
       $scope.$digest()
 
     it "sets the valid placeholder", ->

data/spec/javascripts/app/resources_spec.js.coffee

@@ -0,0 +1,99 @@
+describe "reources", ->
+  beforeEach module("mb.resources")
+
+  $httpBackend = null
+  beforeEach inject ($injector) ->
+    $httpBackend = $injector.get("$httpBackend")
+
+  afterEach ->
+    $httpBackend.verifyNoOutstandingExpectation()
+    $httpBackend.verifyNoOutstandingRequest()
+
+  describe "Database", ->
+    Database = null
+    beforeEach inject ($injector) ->
+      Database = $injector.get("Database")
+
+    it "is defined", ->
+      expect(Database).toBeDefined()
+
+    describe "#query", ->
+      it "queries for all databases", ->
+        $httpBackend.whenGET("/api/databases").respond([])
+        Database.query()
+        $httpBackend.flush()
+
+    describe "#$stats", ->
+      it "queries for database stats", ->
+        $httpBackend.whenGET("/api/databases/test_database/stats").respond({})
+
+        database = new Database(name: "test_database")
+        database.$stats()
+
+        $httpBackend.flush()
+
+  describe "Collection", ->
+    Collection = null
+    beforeEach inject ($injector) ->
+      Collection = $injector.get("Collection")
+      $httpBackend.whenGET("/api/databases/test_database/collections")
+        .respond([])
+
+    it "is defined", ->
+      expect(Collection).toBeDefined()
+
+    describe "#query", ->
+      it "queries for all collections", ->
+        Collection.query(dbName: "test_database")
+        $httpBackend.flush()
+
+    describe "#$stats", ->
+      it "queries for collection stats", ->
+        fakeResponse = foo: "bar"
+        $httpBackend.whenGET("/api/databases/test_database/collections/test_collection/stats")
+          .respond(fakeResponse)
+
+        collection = new Collection(dbName: "test_database", name: "test_collection")
+        collection.$stats (data) ->
+          expect(angular.equals(data, fakeResponse)).toBeTruthy()
+
+        $httpBackend.flush()
+
+  describe "Document", ->
+    Document = null
+    beforeEach inject ($injector) ->
+      Document = $injector.get("Document")
+      $httpBackend.whenGET("/api/databases/test_database/collections/test_collection/documents")
+        .respond([])
+
+    it "is defined", ->
+      expect(Document).toBeDefined()
+
+    describe "#query", ->
+      it "queries for all documents", ->
+        Document.query(dbName: "test_database", collectionName: "test_collection")
+        $httpBackend.flush()
+
+    describe "#$query", ->
+      it "queries for all documents", ->
+        document = new Document(dbName: "test_database", collectionName: "test_collection")
+        document.$query()
+        $httpBackend.flush()
+
+    describe "$get", ->
+      it "gets a document", ->
+        $httpBackend.whenGET("/api/databases/test_database/collections/test_collection/documents/document-id").respond([])
+
+        document = new Document(dbName: "test_database", collectionName: "test_collection", id: "document-id")
+        document.$get()
+
+        $httpBackend.flush()
+
+    describe "$delete", ->
+      it "deletes a document", ->
+        $httpBackend.whenDELETE("/api/databases/test_database/collections/test_collection/documents/document-id").respond([])
+
+        document = new Document(dbName: "test_database", collectionName: "test_collection", id: "document-id")
+        document.$delete()
+
+        $httpBackend.flush()

data/spec/javascripts/app/services_spec.js.coffee

@@ -1,83 +1,43 @@
 describe "services", ->
+  beforeEach module("mb.alerts")
   beforeEach module("mb.services")
+  beforeEach module("mocks")
 
-  describe "alerts", ->
-    it "is defined", inject (alerts) ->
-      expect(alerts).toBeDefined()
+  describe "httpErrorsInterceptor", ->
+    $http = null
+    promise = null
 
-    describe "#nextId", ->
-      it "return the next id for the new flash message", inject (alerts) ->
-        expect(alerts.nextId()).toEqual(1)
-        _(4).times -> alerts.nextId()
-        expect(alerts.nextId()).toEqual(6)
+    interceptor = null
+    alerts = null
+    $q = null
 
-    describe "#push", ->
-      beforeEach inject (alerts) ->
-        spyOn(alerts, "delayedDispose")
+    errorHandler = null
 
-      it "returns an id for the new flash message", inject (alerts) ->
-        expect(alerts.push("info", "Test..")).toEqual(1)
-        expect(alerts.delayedDispose).toHaveBeenCalledWith(1)
+    beforeEach inject ($injector) ->
+      $http = $injector.get("$http")
+      interceptor = $injector.get("httpErrorsInterceptor")
+      alerts = $injector.get("alerts")
+      $q = $injector.get("$q")
 
-        expect(alerts.push("error", "Test error..")).toEqual(2)
-        expect(alerts.delayedDispose).toHaveBeenCalledWith(2)
+      promise = then: jasmine.createSpy("then").andReturn({})
+      interceptor(promise)
 
-      describe "#info", ->
-        it "pushesh the given message", inject (alerts) ->
-          # Given
-          testMessage = "This is a test message!"
-          otherTestMessage = "This is a second test message!"
+      spyOn(alerts, "push")
+      spyOn($q, "reject")
+      errorHandler = promise.then.mostRecentCall.args[1]
 
-          # When
-          alerts.info(testMessage)
-          expect(alerts.delayedDispose).toHaveBeenCalledWith(1)
+    it "alerts an error on failed http request", ->
+      httpResponse = status: 500
+      errorHandler(httpResponse)
 
-          alerts.info(otherTestMessage)
-          expect(alerts.delayedDispose).toHaveBeenCalledWith(2)
+      expect(alerts.push).toHaveBeenCalledWith("error", "Unexpected HTTP error")
+      expect($q.reject).toHaveBeenCalledWith(httpResponse)
 
-          # Then
-          expect(alerts.messages).toContain(id: 1, type: "info", text: testMessage)
-          expect(alerts.messages).toContain(id: 2, type: "info", text: otherTestMessage)
+    describe "when http response includes an error message", ->
+      it "alerts this error", ->
+        httpResponse = status: 500, data:
+          error: "The custom message"
+        errorHandler(httpResponse)
 
-      describe "#error", ->
-        it "pushesh the given message", inject (alerts) ->
-          # Given
-          testMessage = "This is a test message!"
-
-          # When
-          alerts.error(testMessage)
-          expect(alerts.delayedDispose).toHaveBeenCalledWith(1)
-
-          # Then
-          expect(alerts.messages).toContain(id: 1, type: "error", text: testMessage)
-
-    describe "#dispose", ->
-      it "removes a message with the given id", inject (alerts) ->
-        # Given
-        alerts.info("First message")
-        alerts.info("Second message")
-        alerts.info("Third message")
-        alerts.error("Error message")
-
-        # When
-        alerts.dispose(2)
-
-        # Then
-        expect(alerts.messages).toContain(id: 1, type: "info", text: "First message")
-        expect(alerts.messages).not.toContain(id: 2, type: "info", text: "Second message")
-        expect(alerts.messages).toContain(id: 3, type: "info", text: "Third message")
-        expect(alerts.messages).toContain(id: 4, type: "error", text: "Error message")
-
-    describe "#delayedDispose", ->
-      it "removes a message after the given time", inject (alerts, $timeout) ->
-        # Given
-        alerts.info("First message")
-
-        # When
-        alerts.delayedDispose(1)
-        expect(alerts.messages).toContain(id: 1, type: "info", text: "First message")
-
-        $timeout.flush()
-
-        # Then
-        expect(alerts.messages).toEqual([])
+        expect(alerts.push).toHaveBeenCalledWith("error", "The custom message")
+        expect($q.reject).toHaveBeenCalledWith(httpResponse)

data/spec/javascripts/config/{testacular-e2e.conf.js → karma-e2e.conf.js}

@@ -13,7 +13,7 @@ browsers = ["PhantomJS"];
 autoWatch = false;
 singleRun = true;
 
-urlRoot = '/__testacular/';
+urlRoot = '/__karma__/';
 proxies = {
   "/": "http://localhost:3001/"
 };

data/spec/javascripts/config/{testacular.conf.js → karma.conf.js}

@@ -13,9 +13,8 @@ files = [
   "vendor/assets/javascripts/*.js",
 
   // The app
-  "app/assets/javascripts/app/controllers.js.coffee",
-  "app/assets/javascripts/app/**/*.js.coffee",
   "app/assets/javascripts/application.js.coffee",
+  "app/assets/javascripts/app/**/*.js.coffee",
 
   // Specs
   "spec/javascripts/lib/angular-mocks.js",
@@ -25,7 +24,7 @@ files = [
   "spec/javascripts/**/*_spec.js.coffee",
 
   // Templates
-  "app/assets/javascripts/templates/*.html.js"
+  "app/assets/javascripts/compiled_templates/*.html.js"
 ];
 
 preprocessors = {

data/spec/javascripts/e2e/collection_stats_scenario.js.coffee

@@ -0,0 +1,12 @@
+describe "collection stats page", ->
+
+  beforeEach ->
+    browser().navigateTo("/e2e/load_fixtures")
+    browser().navigateTo("/")
+
+    element("table.databases tbody tr a:contains('first_database')").click()
+    element("table.collections tbody tr a:contains('first_collection')").click()
+    element("a.btn:contains('Collection stats')").click()
+
+  it "displays database stats", ->
+    expect(repeater("table tbody tr").count()).toBeGreaterThan(0)

data/spec/javascripts/e2e/collections_scenario.js.coffee

@@ -1,49 +1,88 @@
 describe "collections list page", ->
+  collectionsList = null
+
   beforeEach ->
     browser().navigateTo("/e2e/load_fixtures")
     browser().navigateTo("/")
 
     element("table.databases tbody tr a:contains('first_database')").click()
+    collectionsList = repeater("table.collections tbody tr")
 
   it "navigates to the valid url", ->
     expect(browser().location().url()).toBe("/databases/first_database/collections")
 
+  it "shows the breadcrumbs", ->
+    link = element(".container a.brand")
+    expect(link.text()).toEqual("Mongo Browser")
+    expect(link.attr("href")).toEqual("/")
+
+    dbLink = element(".container .breadcrumbs li:nth-child(1) a")
+    expect(dbLink.text()).toEqual("first_database")
+    expect(dbLink.attr("href")).toEqual("/databases/first_database/collections")
+
   it "displays a valid section title", ->
     title = element("h2").text()
     expect(title).toEqual("first_database collections")
 
   it "displays available collections ordered by name", ->
-    expect(repeater("table.collections tbody tr").column("collection.name"))
-        .toEqual(["first_collection", "second_collection", "system.indexes", "third_collection"])
+    expect(collectionsList.column("collection.name"))
+      .toEqual(["first_collection", "second_collection", "system.indexes", "third_collection"])
 
   it "filters the collections list", ->
     input("value").enter("")
-    expect(repeater("table.collections tbody tr").count()).toBe(4)
-    expect(repeater("table.collections tbody tr").column("collection.name"))
-        .toEqual(["first_collection", "second_collection", "system.indexes", "third_collection"])
+    expect(collectionsList.count()).toBe(4)
+    expect(collectionsList.column("collection.name"))
+      .toEqual(["first_collection", "second_collection", "system.indexes", "third_collection"])
 
     input("value").enter("first")
-    expect(repeater("table.collections tbody tr").count()).toBe(1)
-    expect(repeater("table.collections tbody tr").column("collection.name"))
-        .toEqual(["first_collection"])
+    expect(collectionsList.count()).toBe(1)
+    expect(collectionsList.column("collection.name"))
+      .toEqual(["first_collection"])
 
     input("value").enter("second")
-    expect(repeater("table.collections tbody tr").count()).toBe(1)
-    expect(repeater("table.collections tbody tr").column("collection.name"))
-        .toEqual(["second_collection"])
+    expect(collectionsList.count()).toBe(1)
+    expect(collectionsList.column("collection.name"))
+      .toEqual(["second_collection"])
 
     input("value").enter("collection")
-    expect(repeater("table.collections tbody tr").count()).toBe(3)
-    expect(repeater("table.collections tbody tr").column("collection.name"))
-        .toEqual(["first_collection", "second_collection", "third_collection"])
+    expect(collectionsList.count()).toBe(3)
+    expect(collectionsList.column("collection.name"))
+      .toEqual(["first_collection", "second_collection", "third_collection"])
 
     input("value").enter("not existing")
-    expect(repeater("table.collections tbody tr").count()).toBe(0)
-    expect(element(".filter.alert:visible").text()).toMatch(/Nothing has been found./)
+    expect(collectionsList.count()).toBe(0)
+    expect(element(".alert:visible").text()).toMatch(/Nothing has been found./)
 
     element("button:contains('Clear')").click()
-    expect(repeater("table.collections tbody tr").count()).toBe(4)
+    expect(collectionsList.count()).toBe(4)
+
+  describe "delete a collection", ->
+    deleteCollection = (name) ->
+      element("table.collections tbody tr:contains('#{name}') td:last-child a:contains('Delete')")
+        .click()
+
+    beforeEach ->
+      deleteCollection("third_collection")
+      expect(element("div.modal .modal-body").text())
+        .toContain("Deleting third_collection. Are you sure?")
+
+    describe "when the dialog was disposed", ->
+      beforeEach -> disposeDialog()
+
+      it "does nothig", ->
+        expect(collectionsList.count()).toBe(4)
+        expect(collectionsList.column("collection.name"))
+          .toEqual(["first_collection", "second_collection", "system.indexes", "third_collection"])
+
+    describe "when the dialog was confirmed", ->
+      beforeEach -> confirmDialog()
+
+      it "shows the alert", ->
+        expect(repeater("aside#alerts .alert").count()).toBe(1)
+        expect(repeater("aside#alerts .alert").column("message.text"))
+          .toContain("Collection third_collection has been deleted.")
 
-  it "displays a tab with database stats", ->
-    element(".tabbable a:contains('Database stats')").click()
-    expect(repeater("table tbody tr").count()).toBeGreaterThan(0)
+      it "deletes a database", ->
+        expect(collectionsList.count()).toBe(3)
+        expect(collectionsList.column("collection.name"))
+          .toEqual(["first_collection", "second_collection", "system.indexes"])