mongo_browser 0.2.0.rc2 → 0.2.5

data/spec/javascripts/app/controllers/documents/show_controller_spec.js.coffee

@@ -0,0 +1,94 @@
+describe "documents show controller", ->
+  beforeEach module("mb")
+  beforeEach module("mocks")
+
+  controller = null
+  $scope = null
+
+  $httpBackend = null
+
+  beforeEach inject ($injector, $rootScope, $controller) ->
+    alerts = $injector.get("alerts")
+
+    $routeParams = $injector.get("$routeParams")
+    $routeParams.dbName = "test_database"
+    $routeParams.collectionName = "test_collection"
+    $routeParams.id = "document_id"
+
+    $httpBackend = $injector.get("$httpBackend")
+    $httpBackend.whenGET("/api/databases/test_database/collections/test_collection/documents/document_id")
+      .respond(dbName: "test_database", collectionName: "test_collection", id: "document_id")
+
+    $scope = $rootScope.$new()
+    controller = $controller "documents.show",
+      $scope: $scope
+
+    $scope.$digest()
+    $httpBackend.flush()
+
+  afterEach ->
+    $httpBackend.verifyNoOutstandingExpectation()
+    $httpBackend.verifyNoOutstandingRequest()
+
+  describe "$scope", ->
+    it "assigns variables from $routeParams", ->
+      expect($scope.dbName).toEqual("test_database")
+      expect($scope.collectionName).toEqual("test_collection")
+
+    # TODO create a macro / shared examples
+    describe "$scope.isLoading", ->
+      it "returns true when the resouce it loading", ->
+        controller.loading = true
+        expect($scope.isLoading()).toBeTruthy()
+
+      it "otherwise returns false", ->
+        controller.loading = false
+        expect($scope.isLoading()).toBeFalsy()
+
+    describe "$scope.refresh", ->
+      alerts = null
+
+      beforeEach inject ($injector) ->
+        alerts = $injector.get("alerts")
+
+      it "displays a flash message", ->
+        # Given
+        spyOn(alerts, "info")
+
+        # When
+        $scope.refresh()
+        $httpBackend.flush()
+
+        # Then
+        expect(alerts.info).toHaveBeenCalledWith("Document was refreshed")
+
+      it "fetches a document from the database", ->
+        # Given
+        $httpBackend.whenGET("/api/databases/test_database/collections/test_collection/documents/document_id")
+          .respond({})
+
+        # When
+        $scope.refresh()
+        $httpBackend.flush()
+
+        # Then
+        $httpBackend.verifyNoOutstandingExpectation()
+        $httpBackend.verifyNoOutstandingRequest()
+
+  describe "controller", ->
+    describe "controller.handleNotFoundDocument", ->
+      $location = null
+
+      beforeEach inject ($injector) ->
+        $location = $injector.get("$location")
+        spyOn($location, "path")
+
+      describe "when the response status is 404", ->
+        it "redirects to the documents list page", ->
+          controller.handleNotFoundDocument(status: 404)
+          expect($location.path).toHaveBeenCalledWith("/databases/test_database/collections/test_collection/documents")
+
+      describe "when the rsponse status is not 404", ->
+        it "should not redirect", ->
+          controller.handleNotFoundDocument(status: 500)
+          expect($location.path).not.toHaveBeenCalled()

data/spec/javascripts/app/controllers/{main_spec.js.coffee → main_controller_spec.js.coffee}

@@ -1,5 +1,5 @@
 describe "main", ->
-  beforeEach module("mb.controllers")
+  beforeEach module("mb")
 
   $scope = null
   $httpBackend = null
@@ -8,7 +8,7 @@ describe "main", ->
     $scope = $rootScope.$new()
 
     $httpBackend = $injector.get('$httpBackend')
-    $httpBackend.when("GET", "/api/version.json").respond([])
+    $httpBackend.whenGET("/api/version").respond([])
 
     $controller "main",
       $scope: $scope

data/spec/javascripts/app/controllers/{server_info_spec.js.coffee → server/show_controller_spec.js.coffee}

@@ -1,6 +1,5 @@
-describe "serverInfo", ->
-  beforeEach module("mb.controllers")
-  beforeEach module("mocks")
+describe "servers show controller", ->
+  beforeEach module("mb")
 
   $scope = null
   $httpBackend = null
@@ -8,10 +7,10 @@ describe "serverInfo", ->
   beforeEach inject ($injector, $rootScope, $controller) ->
     $scope = $rootScope.$new()
 
-    $httpBackend = $injector.get('$httpBackend')
-    $httpBackend.when("GET", "/api/server_info.json").respond([])
+    $httpBackend = $injector.get("$httpBackend")
+    $httpBackend.whenGET("/api/server_info").respond([])
 
-    $controller "serverInfo",
+    $controller "servers.show",
       $scope: $scope
 
     $httpBackend.flush()

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

@@ -1,47 +1,103 @@
 describe "directives", ->
   beforeEach module("mb.directives")
 
-  $scope = null
+  $rootScope = null
   element = null
 
   describe "osEsc", ->
-    beforeEach inject ($compile, $rootScope) ->
-      $scope = $rootScope.$new()
-      $scope.bar = ->
+    beforeEach inject ($compile, _$rootScope_) ->
+      $rootScope = _$rootScope_
+      $rootScope.bar = ->
 
-      element = $compile('<input type="text" on-esc="bar()" />')($scope)
-      $scope.$digest()
+      element = angular.element """
+      <input type="text" on-esc="bar()" />
+      """
+      $compile(element)($rootScope)
+      $rootScope.$digest()
 
     it "calls the given function when the ESC was pressed", ->
-      spyOn($scope, 'bar')
+      spyOn($rootScope, 'bar')
 
       event = jQuery.Event("keyup", keyCode: 27)
       element.trigger(event)
 
-      expect($scope.bar).toHaveBeenCalled()
+      expect($rootScope.bar).toHaveBeenCalled()
 
     it "does nothing on other keys", ->
-      spyOn($scope, 'bar')
+      spyOn($rootScope, 'bar')
 
       event = jQuery.Event("keyup", keyCode: 13)
       element.trigger(event)
 
-      expect($scope.bar).not.toHaveBeenCalled()
+      expect($rootScope.bar).not.toHaveBeenCalled()
 
-  describe "deleteButton", ->
-    beforeEach inject ($compile, $rootScope) ->
-      $scope = $rootScope.$new()
-      $scope.bar = ->
+  describe "showButton", ->
+    renderedButton = null
+
+    # TODO use this trick in other places
+    compileTemplate = (template, callback = ->) ->
+      beforeEach inject ($compile, $rootScope) ->
+        element = angular.element(template)
+
+        $compile(element)($rootScope)
+        $rootScope.$digest()
+
+        callback(element)
+
+    describe "when a custom label is not provided", ->
+      template = """
+       <div>
+         <show-button path="/foo/bar/biz" />
+       </div>
+       """
+
+      compileTemplate template, (element) ->
+        renderedButton = element.find("a")
+
+      it "renders the button", ->
+        expect(renderedButton.length).toBe(1)
+        expect(renderedButton.hasClass("btn")).toBeTruthy()
+        expect(renderedButton.hasClass("btn-success")).toBeTruthy()
+
+      it "renders the path", ->
+        expect(renderedButton.attr("href")).toEqual("/foo/bar/biz")
 
+      it "renders the custom label", ->
+        expect(renderedButton.text()).toContain("Show")
+
+    describe "when a custom label is provided", ->
       template = """
-                 <div>
-                   <delete-button ng-click="bar()" />
-                 </div>
-                 """
-      element = $compile(template)($scope)
-      $scope.$digest()
-
-    it "renders bar button", ->
+       <div>
+         <show-button label="Display me the foo" path="/foo/bar" />
+       </div>
+       """
+
+      compileTemplate template, (element) ->
+        renderedButton = element.find("a")
+
+      it "renders the button", ->
+        expect(renderedButton.length).toBe(1)
+        expect(renderedButton.hasClass("btn")).toBeTruthy()
+        expect(renderedButton.hasClass("btn-success")).toBeTruthy()
+        expect(renderedButton.attr("href")).toEqual("/foo/bar")
+
+      it "renders the custom label", ->
+        expect(renderedButton.text()).toContain("Display me the foo")
+
+  describe "deleteButton", ->
+    beforeEach inject ($compile, $rootScope) ->
+      $rootScope = $rootScope
+      $rootScope.bar = ->
+
+      element = angular.element """
+      <div>
+        <delete-button ng-click="bar()" />
+      </div>
+      """
+      $compile(element)($rootScope)
+      $rootScope.$digest()
+
+    it "renders delete button", ->
       button = element.find("a")
 
       expect(button.length).toBe(1)
@@ -50,9 +106,37 @@ describe "directives", ->
       expect(button.text()).toContain("Delete")
 
     it "ng-click", ->
-      spyOn($scope, 'bar')
+      spyOn($rootScope, 'bar')
 
       button = element.find("button")
       button.click()
 
-      expect($scope.bar).not.toHaveBeenCalled()
+      expect($rootScope.bar).not.toHaveBeenCalled()
+
+  describe "refreshButton", ->
+    beforeEach inject ($compile) ->
+      $rootScope.refresh = ->
+
+      element = angular.element """
+      <div>
+        <refresh-button ng-click="refresh()" />
+      </div>
+      """
+      $compile(element)($rootScope)
+      $rootScope.$digest()
+
+    it "renders delete button", ->
+      button = element.find("a")
+
+      expect(button.length).toBe(1)
+      expect(button.hasClass("btn")).toBeTruthy()
+      expect(button.text()).toContain("Refresh")
+
+    describe "ng-click on the button", ->
+      it "calls #refresh() method", ->
+        spyOn($rootScope, "refresh")
+
+        button = element.find("a")
+        button.click()
+
+        expect($rootScope.refresh).toHaveBeenCalled()

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

@@ -58,17 +58,17 @@ describe "filters", ->
       expect(filter(o)).toContain('<span class="null">null</span>')
 
     it "can format ObjectId", ->
-      o = {
+      document = {
         _id: { $oid: "50bfc4b6dac5d5630800017a" },
         foo: "something",
         comapany_id: { $oid: "50bfc4b6dac5d56308000119" }
       }
 
-      expect(filter(o)).toContain('<span class="key">_id:</span>')
-      expect(filter(o)).toContain('ObjectId(<span class="string">"50bfc4b6dac5d5630800017a"</span>)')
+      expect(filter(document)).toContain('<span class="key">_id:</span>')
+      expect(filter(document)).toContain('ObjectId(<span class="string">"50bfc4b6dac5d5630800017a"</span>)')
 
-      expect(filter(o)).toContain('<span class="key">comapany_id:</span>')
-      expect(filter(o)).toContain('ObjectId(<span class="string">"50bfc4b6dac5d56308000119"</span>)')
+      expect(filter(document)).toContain('<span class="key">comapany_id:</span>')
+      expect(filter(document)).toContain('ObjectId(<span class="string">"50bfc4b6dac5d56308000119"</span>)')
 
   # url helpers
 
@@ -97,3 +97,29 @@ describe "filters", ->
     it "generates na url for the given collection documents", ->
       collection = { dbName: "foo", name: "bars" }
       expect(filter(collection)).toEqual("/databases/foo/collections/bars/documents")
+
+  describe "#documentPath", ->
+    filter = null
+
+    beforeEach inject (documentPathFilter) ->
+      filter = documentPathFilter
+
+    it "without parameters generates an url with placeholders", ->
+      expect(filter()).toEqual("/databases/:dbName/collections/:collectionName/documents/:id")
+
+    it "generates na url for the given collection documents", ->
+      document = { dbName: "foo", collectionName: "bars", id: "documentId" }
+      expect(filter(document)).toEqual("/databases/foo/collections/bars/documents/documentId")
+
+  describe "documentPrettyTime", ->
+    filter = null
+
+    beforeEach inject (documentPrettyTimeFilter) ->
+      filter = documentPrettyTimeFilter
+
+    it "extracts time from document id", ->
+      expect(filter(id: "50c33814dac5d5c9310001bd"))
+        .toEqual("Sat, 08 Dec 2012 12:52:36 GMT")
+
+      expect(filter(id: "50d7134ddac5d501aa000003"))
+        .toEqual("Sun, 23 Dec 2012 14:21:01 GMT")

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

@@ -0,0 +1,138 @@
+describe "mb.alerts", ->
+  beforeEach module("mb.alerts")
+  beforeEach module("mocks")
+
+  describe "controller", ->
+    $scope = null
+    alerts = null
+
+    beforeEach inject ($injector, $rootScope, $controller) ->
+      $scope = $rootScope.$new()
+
+      alerts = $injector.get("alerts")
+
+      $controller "alerts",
+        $scope: $scope,
+        alerts: alerts
+
+    it "assings flash messages", ->
+      expect($scope.alertMessages).toBeDefined()
+      expect($scope.alertMessages).toEqual([])
+
+      alerts.info("Test message.")
+      expect($scope.alertMessages).toContain(id: 1, type: "info", text: "Test message.")
+
+    describe "#disposeAlert", ->
+      it "disposes an alert at the given index", ->
+        # Given
+        alerts.info("Information..")
+        alerts.error("Error..")
+        spyOn(alerts, "dispose").andCallThrough()
+
+        # When
+        $scope.disposeAlert(2)
+
+        # Then
+        expect(alerts.dispose).toHaveBeenCalledWith(2)
+        expect($scope.alertMessages).toContain(id: 1, type: "info", text: "Information..")
+        expect($scope.alertMessages).not.toContain(id: 2, type: "error", text: "Error..")
+
+  describe "directive", ->
+    $scope = null
+    element = null
+
+    beforeEach module("public/ng/templates/alerts.html")
+
+    beforeEach inject ($rootScope, $compile) ->
+      $scope = $rootScope
+
+      element = angular.element "<alerts></alerts>"
+      $compile(element)($scope)
+      $scope.$digest()
+
+    it "renders alerts", ->
+      $scope.$apply -> $scope.alertMessages = [
+        type: "info", text: "Test message"
+      ]
+      expect(element.find(".alert-info").length).toEqual(1)
+
+  describe "service", ->
+    it "is defined", inject (alerts) ->
+      expect(alerts).toBeDefined()
+
+    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)
+
+    describe "#push", ->
+      beforeEach inject (alerts) ->
+        spyOn(alerts, "delayedDispose")
+
+      it "returns an id for the new flash message", inject (alerts) ->
+        expect(alerts.push("info", "Test..")).toEqual(1)
+        expect(alerts.delayedDispose).toHaveBeenCalledWith(1)
+
+        expect(alerts.push("error", "Test error..")).toEqual(2)
+        expect(alerts.delayedDispose).toHaveBeenCalledWith(2)
+
+      describe "#info", ->
+        it "pushesh the given message", inject (alerts) ->
+          # Given
+          testMessage = "This is a test message!"
+          otherTestMessage = "This is a second test message!"
+
+          # When
+          alerts.info(testMessage)
+          expect(alerts.delayedDispose).toHaveBeenCalledWith(1)
+
+          alerts.info(otherTestMessage)
+          expect(alerts.delayedDispose).toHaveBeenCalledWith(2)
+
+          # Then
+          expect(alerts.messages).toContain(id: 1, type: "info", text: testMessage)
+          expect(alerts.messages).toContain(id: 2, type: "info", text: otherTestMessage)
+
+      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([])