facebook-js-stub 0.1.3 → 0.1.4

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gem "jasmine"

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Involver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Facebook JS Stub
+
+## Description
+
+This library facilitates the testing of code that interacts with Facebook via the official JavaScript SDK. It does this
+by providing a fake `FB` JavaScript module that mimics the official module. It also provides helper methods for
+simulating different Facebook states.
+
+## Install
+
+### Jasmine on Rails 3.1
+
+If using the edge version of [Jasmine](http://pivotal.github.com/jasmine/) with the Rails 3.1 asset pipeline:
+
+1. Add the gem to your Gemfile:
+
+        gem "facebook-js-stub", :git => "git://github.com/involver/facebook-js-stub.git"
+
+2. Add the `facebook-js-stub.js` asset to your `src_files` in `spec/javascripts/support/jasmine.yml`:
+
+        src_files:
+          - ...
+          - assets/facebook-js-stub.js
+
+### Jasmine on another project
+
+1. Copy `vendor/assets/javascripts/facebook-js-stub.js` to `spec/javascripts/helpers/`.
+2. If you're explicitly setting helpers in your Jasmine configuration, add the new file:
+
+        helper_files:
+          - ...
+          - helpers/facebook-js-stub.js
+
+## Usage
+
+`FB` is a module that simulates the official Facebook JavaScript library.
+
+`FBStub` is a module that provides methods for simulating a user's Facebook state and for simulating calls from
+Facebook to your callbacks.
+
+### FB.init(options)
+
+As with the official Facebook library, you need to initialize it with your Application ID before anything else. Add the
+following in a `beforeEach`:
+
+    FB.init({appId: 123});
+
+### FB.getLoginStatus(callback)
+
+The given callback is called immediately and synchronously using the user's Facebook state as set via `FBStub`.
+
+See `FBStub.loggedIn()`, `FBStub.notLoggedIn()`, `FBStub.connected()`, and `FBStub.notConnected()`.
+
+### FB.api(path, callback)
+
+The given request is recorded. The `callback` is not immediately called but stored for later use.
+
+To trigger a simulated response from Facebook, see `FBStub.respondToApiRequest()`.
+
+### FBStub.loggedIn(userId)
+
+This simulates a logged in user.
+
+### FBStub.notLoggedIn()
+
+This simulates a logged out user.
+
+### FBStub.connected()
+
+This simulates a user having authorized the current application.
+
+### FBStub.notConnected()
+
+This simulates a user having not authorized the current application.
+
+### FBStub.respondToApiRequest(path, response)
+
+This responds to a previously recorded `FB.api()` request matching the given `path`. It will synchronously call the
+stored callback with the given `response`.
+
+## Notes
+
+* When using `facebook-js-stub.js`, do not include Facebook's official JavaScript library. They both use the `FB`
+  namespace, so one will override the other.
+
+## License
+
+Please see the included license file.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+begin
+  require 'jasmine'
+  load 'jasmine/tasks/jasmine.rake'
+rescue LoadError
+  task :jasmine do
+    abort "Jasmine is not available. In order to run jasmine, you must: (sudo) gem install jasmine"
+  end
+end

data/lib/facebook-js-stub/version.rb

@@ -0,0 +1,7 @@
+module FacebookJsStub
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 4
+
+  VERSION = [MAJOR, MINOR, PATCH].join('.')
+end

data/spec/javascripts/api_spec.js

@@ -0,0 +1,97 @@
+describe("FB.api", function () {
+  var callbacks;
+
+  beforeEach(function () {
+    callbacks = {
+      api:function () {
+      }
+    };
+    spyOn(callbacks, 'api');
+  });
+
+  describe("when FB has not been initialized", function () {
+    beforeEach(function () {
+      FB.api(callbacks.api);
+    });
+
+    it("should not call the callback function", function () {
+      expect(callbacks.api).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("when FB has been initialized", function () {
+    var response;
+
+    function shared_callback_examples() {
+      it("should match open requests", function() {
+        expect(FBStub.findApiRequest("/some/path")).toBeDefined();
+      });
+
+      it("should not yet call the callback function", function() {
+        expect(callbacks.api).not.toHaveBeenCalled();
+      });
+
+      describe("when the API response is triggered for the same path", function() {
+        beforeEach(function() {
+          FBStub.respondToApiRequest("/some/path", response);
+        });
+
+        it("should yield the response to the callback function", function() {
+          expect(callbacks.api).toHaveBeenCalledWith(response);
+        });
+      });
+
+      describe("when the API response is triggered for a different path", function() {
+        beforeEach(function() {
+          FBStub.respondToApiRequest("/another/path", response);
+        });
+
+        it("should not yet call the callback function", function() {
+          expect(callbacks.api).not.toHaveBeenCalled();
+        });
+      });
+    }
+
+    describe("when given path and callback params", function() {
+      beforeEach(function () {
+        FB.init({appId:123});
+        FB.api("/some/path", callbacks.api);
+
+        response = {
+          data: [
+            {
+              name: "Example",
+              access_token: "",
+              category: "Community",
+              id: "1234567890"
+            }
+          ]
+        };
+      });
+
+      shared_callback_examples();
+    });
+
+    describe("when given path, method ,object, and callback params", function() {
+      var myObj = { };
+
+      beforeEach(function () {
+        FB.init({appId:123});
+        FB.api("/some/path", "post", myObj, callbacks.api);
+
+        response = {
+          data: [
+            {
+              name: "Example",
+              access_token: "",
+              category: "Community",
+              id: "1234567890"
+            }
+          ]
+        };
+      });
+
+      shared_callback_examples();
+    });
+  });
+});

data/spec/javascripts/get_login_status_spec.js

@@ -0,0 +1,81 @@
+describe("FB.getLoginStatus", function() {
+  var callbacks;
+
+  beforeEach(function() {
+    callbacks = {
+      getLoginStatus: function() {}
+    };
+    spyOn(callbacks, 'getLoginStatus');
+  });
+
+  describe("when FB has not been initialized", function() {
+    it("should not call the callback function", function() {
+      FB.getLoginStatus(callbacks.getLoginStatus);
+      expect(callbacks.getLoginStatus).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("when FB has been initialized", function() {
+    beforeEach(function() {
+      FB.init({appId: 123});
+    });
+
+    it("should call the callback function", function() {
+      FB.getLoginStatus(callbacks.getLoginStatus);
+      expect(callbacks.getLoginStatus).toHaveBeenCalled();
+    });
+
+    describe("when the user is logged in", function() {
+      beforeEach(function() {
+        FBStub.loggedIn({userID: 123});
+      });
+
+      describe("when the user has authorized the application", function() {
+        beforeEach(function() {
+          FBStub.connected();
+        });
+
+        it("should yield a hash with a connected response", function() {
+          FB.getLoginStatus(callbacks.getLoginStatus);
+          expect(callbacks.getLoginStatus).toHaveBeenCalledWith({
+            status : 'connected',
+            authResponse: {
+              accessToken: '',
+              expiresIn: 4095,
+              signedRequest: '',
+              userID: 123
+            }
+          });
+        });
+      });
+
+      describe("when the user has not authorized the application", function() {
+        beforeEach(function() {
+          FBStub.notConnected();
+        });
+
+        it("should yield a hash with an unauthorized status", function() {
+          FB.getLoginStatus(callbacks.getLoginStatus);
+          expect(callbacks.getLoginStatus).toHaveBeenCalledWith({
+            status: 'not_authorized',
+            authResponse: null
+          });
+        })
+      });
+    });
+
+    describe("when the user is not logged in", function() {
+      beforeEach(function() {
+        FBStub.notLoggedIn();
+      });
+
+      it("should yield a hash an unknown status", function() {
+        FB.getLoginStatus(callbacks.getLoginStatus);
+        expect(callbacks.getLoginStatus).toHaveBeenCalledWith({
+          status: 'unknown',
+          authResponse: null
+        });
+      })
+    });
+  });
+});

data/spec/javascripts/helpers/spec_helper.js

@@ -0,0 +1,3 @@
+beforeEach(function() {
+  FBStub.reset();
+});

data/spec/javascripts/login_spec.js

@@ -0,0 +1,101 @@
+describe("FB.login", function() {
+  var callbacks;
+
+  beforeEach(function() {
+    callbacks = {
+      login: function() {}
+    };
+    spyOn(callbacks, 'login');
+  });
+
+  describe("when FB has not been initialized", function() {
+    beforeEach(function() {
+      FB.login(callbacks.login);
+    });
+
+    describe("when the user logs in and authorizes the application", function() {
+      beforeEach(function() {
+        FBStub.logInAndAuthorize();
+      });
+
+      it("should not call the callback function", function() {
+        expect(callbacks.login).not.toHaveBeenCalled();
+      });
+    });
+
+    describe("when the user does not log in or authorize the application", function() {
+      beforeEach(function() {
+        FBStub.logInAndDeny();
+      });
+
+      it("should not call the callback function", function() {
+        expect(callbacks.login).not.toHaveBeenCalled();
+      });
+    });
+
+    describe("when the user does not log in", function() {
+      beforeEach(function() {
+        FBStub.abortLogIn();
+      });
+
+      it("should not call the callback function", function() {
+        expect(callbacks.login).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("when FB has been initialized", function() {
+    beforeEach(function() {
+      FB.init({appId: 123});
+      FB.login(callbacks.login);
+    });
+
+    it("should not yet call the callback function", function() {
+      expect(callbacks.login).not.toHaveBeenCalled();
+    });
+
+    describe("when the user logs in and authorizes the application", function() {
+      beforeEach(function() {
+        FBStub.logInAndAuthorize();
+      });
+
+      it("should yield an object with an authorized response", function() {
+        expect(callbacks.login).toHaveBeenCalledWith({
+          status: "connected",
+          authResponse: {
+            accessToken: "",
+            userID: "",
+            expiresIn: 4374,
+            signedRequest: ""
+          }
+        });
+      });
+    });
+
+    describe("when the user logs in and does not authorize the application", function() {
+      beforeEach(function() {
+        FBStub.logInAndDeny();
+      });
+
+      it("should yield an object with an authorized status", function() {
+        expect(callbacks.login).toHaveBeenCalledWith({
+          status: "not_authorized",
+          authResponse: null
+        });
+      });
+    });
+
+    describe("when the user does not log in", function() {
+      beforeEach(function() {
+        FBStub.abortLogIn();
+      });
+
+      it("should yield an object with an unknown status", function() {
+        expect(callbacks.login).toHaveBeenCalledWith({
+          status: "unknown",
+          authResponse: null
+        });
+      });
+    });
+  });
+});

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,2 @@
+src_files:
+    - src/**/*.js

data/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,23 @@
+module Jasmine
+  class Config
+
+    # Add your overrides or custom config code here
+
+  end
+end
+
+
+# Note - this is necessary for rspec2, which has removed the backtrace
+module Jasmine
+  class SpecBuilder
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {} do
+        me.report_spec(spec["id"])
+      end
+    end
+  end
+end

data/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::Dependencies.rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::Dependencies.rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/src/fb.js

@@ -0,0 +1,58 @@
+var FB = (function(){
+  var self = { };
+
+  self.init = function(options) {
+    FBStub.appId(options.appId);
+  };
+
+  self.login = function(callback) {
+    if (!FBStub.initialized()) return;
+    FBStub.loginCallback = callback;
+  };
+
+  self.getLoginStatus = function(callback) {
+    if (!FBStub.initialized()) return;
+    var status;
+    var authResponse = null;
+
+    if (FBStub.isLoggedIn()) {
+      if (FBStub.isConnected()) {
+        status = "connected";
+        authResponse = {
+          accessToken: "",
+          expiresIn: 4095,
+          signedRequest: "",
+          userID: FBStub.userID()
+        };
+      }
+      else {
+        status = "not_authorized";
+      }
+    }
+    else {
+      status = "unknown";
+    }
+
+    callback({
+      status: status,
+      authResponse: authResponse
+    });
+  };
+
+  self.api = function(path, method, params, callback) {
+    var callbackMethod;
+
+    if (typeof method === 'function') {
+      callbackMethod = method;
+    } else {
+      if (typeof params == 'function') {
+        callbackMethod = params;
+      } else {
+        callbackMethod = callback;
+      }
+    }
+    FBStub.addApiRequest(path, callbackMethod);
+  };
+
+  return self;
+}( ));

data/src/fb_stub.js

@@ -0,0 +1,107 @@
+var FBStub = (function() {
+  var self = { };
+
+  var state, apiRequests;
+
+  var initialize = function() {
+    state = {
+      'loggedIn': false,
+      'connected': false,
+      'appId': null,
+      'user': {}
+    };
+    apiRequests = { };
+  };
+
+  initialize();
+
+  self.addApiRequest = function(path, callback) {
+    apiRequests[path] = callback;
+  };
+
+  self.findApiRequest = function(path) {
+    return apiRequests[path];
+  };
+
+  self.loggedIn = function(user) {
+    state.loggedIn = true;
+    state.user = user || {};
+  };
+
+  self.notLoggedIn = function() {
+    state.loggedIn = false;
+    state.user = {};
+  };
+
+  self.connected = function() {
+    state.connected = true;
+  };
+
+  self.notConnected = function() {
+    state.connected = false;
+  };
+
+  self.isLoggedIn = function() {
+    return state.loggedIn;
+  };
+
+  self.isConnected = function() {
+    return state.connected;
+  };
+
+  self.userID = function() {
+    return state.user.userID;
+  };
+
+  self.appId = function(id) {
+    if (id) {
+      state.appId = id;
+    }
+    return state.appId;
+  };
+
+  self.reset = function() {
+    initialize();
+  };
+
+  self.logInAndAuthorize = function() {
+    if (!self.initialized()) return;
+    self.loginCallback({
+      status: "connected",
+      authResponse: {
+        accessToken: "",
+        userID: "",
+        expiresIn: 4374,
+        signedRequest: ""
+      }
+    });
+  };
+
+  self.logInAndDeny = function() {
+    if (!self.initialized()) return;
+    self.loginCallback({
+      status: "not_authorized",
+      authResponse: null
+    });
+  };
+
+  self.abortLogIn = function() {
+    if (!self.initialized()) return;
+    self.loginCallback({
+      status: "unknown",
+      authResponse: null
+    });
+  };
+
+  self.respondToApiRequest = function(path, response) {
+    if (typeof(apiRequests[path]) === 'undefined') return;
+    apiRequests[path](response);
+  };
+
+  self.initialized = function() {
+    var appId = state.appId;
+    return (typeof(appId) == 'number' || typeof(appId) == "string");
+  };
+
+  return self;
+}( ));

metadata

@@ -1,11 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: facebook-js-stub
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
 - Involver
+- Brian Norton
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -17,9 +18,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- /Users/nort/git/facebook-js-stub/lib/facebook-js-stub/engine.rb
-- /Users/nort/git/facebook-js-stub/lib/facebook-js-stub.rb
-- /Users/nort/git/facebook-js-stub/vendor/assets/javascripts/facebook-js-stub.js
+- lib/facebook-js-stub/engine.rb
+- lib/facebook-js-stub/version.rb
+- lib/facebook-js-stub.rb
+- spec/javascripts/api_spec.js
+- spec/javascripts/get_login_status_spec.js
+- spec/javascripts/helpers/spec_helper.js
+- spec/javascripts/login_spec.js
+- spec/javascripts/support/jasmine.yml
+- spec/javascripts/support/jasmine_config.rb
+- spec/javascripts/support/jasmine_runner.rb
+- src/fb.js
+- src/fb_stub.js
+- vendor/assets/javascripts/facebook-js-stub.js
+- Gemfile
+- MIT-LICENSE
+- Rakefile
+- README.md
 homepage: 
 licenses: []
 post_install_message: 
@@ -43,6 +58,6 @@ rubyforge_project:
 rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: ''
+summary: A mocking framework for the FB javascript library.
 test_files: []
 has_rdoc: