RubyGems - citygate - Versions diffs - 0.0.5 → 0.0.6 - Mend

citygate 0.0.5 → 0.0.6

Files changed (148) hide show

data/spec/dummy/public/404.html ADDED Viewed

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/422.html ADDED Viewed

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/500.html ADDED Viewed

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+  </div>
+</body>
+</html>

data/spec/dummy/public/favicon.ico ADDED Viewed

File without changes

data/spec/dummy/script/rails ADDED Viewed

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/dummy/spec/controllers/admin/admin_controller_spec.rb ADDED Viewed

@@ -0,0 +1,10 @@
+require 'spec_helper'
+describe Citygate::Admin::ApplicationController do
+  it "should exist" do
+    Citygate.const_defined?('Admin').should be_true
+    Citygate::Admin.const_defined?('ApplicationController').should be_true
+  end
+end

data/spec/dummy/spec/controllers/admin/users_spec.rb ADDED Viewed

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe Citygate::Admin::UsersController do
+  before (:each) do
+    @user = Factory.create(:user)
+    sign_in @user
+  end
+  it "should get the defined number of users or less at a time" do
+    get :index
+    assigns(:users).size.should be <= Citygate::Engine.will_paginate_options[:per_page]
+  end
+end

data/spec/dummy/spec/controllers/home_controller_spec.rb ADDED Viewed

@@ -0,0 +1,12 @@
+require 'spec_helper'
+describe Citygate::HomeController do
+  describe "GET 'index'" do
+    it "should be successful" do
+      get :index
+      response.should be_success
+    end
+  end
+end

data/spec/dummy/spec/controllers/omniauth_spec.rb ADDED Viewed

@@ -0,0 +1,73 @@
+require 'spec_helper'
+describe Citygate::Users::OmniauthCallbacksController do
+  shared_examples "a provider for" do |provider|
+    describe "provider" do
+      before (:each) do
+        request.env["omniauth.auth"] = OmniAuth.config.mock_auth[provider]
+        request.env["devise.mapping"] = Devise.mappings[:user]
+      end
+      it "should create a new user" do
+        expect {
+          get provider
+        }.to change{Citygate::User.count}.by(1)
+      end
+      it "should create a new authorization" do
+        expect {
+          get provider
+        }.to change{Citygate::Authorization.count}.by(1)
+      end
+      context "limiting users" do
+        before (:each) do
+          Citygate::Engine.no_of_users = 1
+          Factory.create(:user)
+          request.env["omniauth.auth"] = OmniAuth.config.mock_auth[provider]
+          request.env["devise.mapping"] = Devise.mappings[:user]
+        end
+        it "should not create a new user" do
+          expect {
+            get provider
+          }.not_to change{Citygate::User.count}
+        end
+        it "should not create a new authorization" do
+          expect {
+            get provider
+          }.not_to change{Citygate::Authorization.count}
+        end
+      end
+      context "not changing the database" do
+        before (:each) do
+          get provider
+        end
+        it "should create a authorization for #{provider} provider" do
+          assigns(:user).authorizations.last.provider.should == provider.to_s.capitalize
+        end
+        it "should create a authorization for the right user" do
+          assigns(:user).id.should == Citygate::Authorization.last.user_id
+        end
+        it "should create a user with the correct email" do
+          assigns(:user).email.should == "zamith@groupbuddies.com"
+        end
+      end
+    end
+  end
+  context "facebook" do
+    it_behaves_like "a provider for", :facebook
+  end
+  context "google" do
+    it_behaves_like "a provider for", :google
+  end
+end

data/spec/dummy/spec/factories.rb ADDED Viewed

@@ -0,0 +1,33 @@
+Factory.define :user, :class => "Citygate::User" do |f|
+  f.first_name            'User'
+  f.email                 'example@example.com'
+  f.password              'bigpasswordisbig'
+  f.password_confirmation 'bigpasswordisbig'
+  # required if the Devise Confirmable module is used
+  f.confirmed_at           Time.now
+end
+Factory.define :facebook_auth, :class => "Citygate::Authorization" do |f|
+  f.provider   'Facebook'
+  f.uid        '28'
+  f.name       'User'
+  f.link       'http://www.facebook.com/luis.zamith'
+  f.image_url  'http://graph.facebook.com/754864768/picture?type=square'
+end
+Factory.define :google_auth, :class => "Citygate::Authorization" do |f|
+  f.provider   'Google'
+  f.uid        '28'
+  f.name       'User'
+end
+Factory.define :facebook_user, :parent => :user do |user|
+  user.first_name nil
+  user.after_create {|fb_user| Factory.create(:facebook_auth, :user => fb_user)}
+end
+Factory.define :google_user, :parent => :user do |user|
+  user.first_name nil
+  user.after_create {|g_user| Factory.create(:google_auth, :user => g_user)}
+end

data/spec/dummy/spec/javascripts/UserSpec.js ADDED Viewed

@@ -0,0 +1,14 @@
+describe("User listing", function() {
+  beforeEach(function() {
+    loadFixtures("user_listing.html");
+  });
+  it("should add the previous page to the history", function() {
+    spyOnEvent($(".next_page"), 'click');
+    $(".next_page").click();
+    expect('click').toHaveBeenTriggeredOn($('.next_page'));
+  });
+});

data/spec/dummy/spec/javascripts/fixtures/user_listing.html ADDED Viewed

@@ -0,0 +1,20 @@
+<div id="container" class="container">
+  <div id="users">
+    <div class="user">
+      <span class="email">user@example.com</span>
+      <span>First User</span>
+      <div class="user-links">
+        <a href="/admin/users/1" class="show-link">Show</a>
+        <a href="/admin/users/1/edit" class="edit-link">Edit</a>
+      </div>
+    </div>
+    <div class="pagination">
+      <span class="previous_page disabled">Previous</span>
+      <em class="current">1</em>
+      <a rel="next" href="/admin/users?page=2">2</a>
+      <a href="/admin/users?page=3">3</a>
+      <a class="next_page" rel="next" href="/admin/users?page=2">Next</a></div>
+    </div>
+  </div>
+</div>

data/spec/dummy/spec/javascripts/helpers/SpecHelper.js ADDED Viewed

@@ -0,0 +1,9 @@
+beforeEach(function() {
+  this.addMatchers({
+    toBePlaying: function(expectedSong) {
+      var player = this.actual;
+      return player.currentlyPlayingSong === expectedSong &&
+             player.isPlaying;
+    }
+  });
+});

data/spec/dummy/spec/javascripts/helpers/jasmine-jquery.js ADDED Viewed

@@ -0,0 +1,306 @@
+var readFixtures = function() {
+  return jasmine.getFixtures().proxyCallTo_('read', arguments);
+};
+var preloadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('preload', arguments);
+};
+var loadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('load', arguments);
+};
+var setFixtures = function(html) {
+  jasmine.getFixtures().set(html);
+};
+var sandbox = function(attributes) {
+  return jasmine.getFixtures().sandbox(attributes);
+};
+var spyOnEvent = function(selector, eventName) {
+  jasmine.JQuery.events.spyOn(selector, eventName);
+};
+jasmine.getFixtures = function() {
+  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
+};
+jasmine.Fixtures = function() {
+  this.containerId = 'jasmine-fixtures';
+  this.fixturesCache_ = {};
+  this.fixturesPath = 'spec/javascripts/fixtures';
+};
+jasmine.Fixtures.prototype.set = function(html) {
+  this.cleanUp();
+  this.createContainer_(html);
+};
+jasmine.Fixtures.prototype.preload = function() {
+  this.read.apply(this, arguments);
+};
+jasmine.Fixtures.prototype.load = function() {
+  this.cleanUp();
+  this.createContainer_(this.read.apply(this, arguments));
+};
+jasmine.Fixtures.prototype.read = function() {
+  var htmlChunks = [];
+  var fixtureUrls = arguments;
+  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
+    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
+  }
+  return htmlChunks.join('');
+};
+jasmine.Fixtures.prototype.clearCache = function() {
+  this.fixturesCache_ = {};
+};
+jasmine.Fixtures.prototype.cleanUp = function() {
+  jQuery('#' + this.containerId).remove();
+};
+jasmine.Fixtures.prototype.sandbox = function(attributes) {
+  var attributesToSet = attributes || {};
+  return jQuery('<div id="sandbox" />').attr(attributesToSet);
+};
+jasmine.Fixtures.prototype.createContainer_ = function(html) {
+  var container;
+  if(html instanceof jQuery) {
+    container = jQuery('<div id="' + this.containerId + '" />');
+    container.html(html);
+  } else {
+    container = '<div id="' + this.containerId + '">' + html + '</div>'
+  }
+  jQuery('body').append(container);
+};
+jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {
+  if (typeof this.fixturesCache_[url] == 'undefined') {
+    this.loadFixtureIntoCache_(url);
+  }
+  return this.fixturesCache_[url];
+};
+jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
+  var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
+  var request = new XMLHttpRequest();
+  request.open("GET", url + "?" + new Date().getTime(), false);
+  request.send(null);
+  this.fixturesCache_[relativeUrl] = request.responseText;
+};
+jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
+  return this[methodName].apply(this, passedArguments);
+};
+jasmine.JQuery = function() {};
+jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
+  return jQuery('<div/>').append(html).html();
+};
+jasmine.JQuery.elementToString = function(element) {
+  return jQuery('<div />').append($(element).clone()).html();
+};
+jasmine.JQuery.matchersClass = {};
+(function(namespace) {
+  var data = {
+    spiedEvents: {},
+    handlers:    []
+  };
+  namespace.events = {
+    spyOn: function(selector, eventName) {
+      var handler = function(e) {
+        data.spiedEvents[[selector, eventName]] = e;
+      };
+      jQuery(selector).bind(eventName, handler);
+      data.handlers.push(handler);
+    },
+    wasTriggered: function(selector, eventName) {
+      return !!(data.spiedEvents[[selector, eventName]]);
+    },
+    wasPrevented: function(selector, eventName) {
+      return data.spiedEvents[[selector, eventName]].isDefaultPrevented();
+    },
+    cleanUp: function() {
+      data.spiedEvents = {};
+      data.handlers    = [];
+    }
+  }
+})(jasmine.JQuery);
+(function(){
+  var jQueryMatchers = {
+    toHaveClass: function(className) {
+      return this.actual.hasClass(className);
+    },
+    toBeVisible: function() {
+      return this.actual.is(':visible');
+    },
+    toBeHidden: function() {
+      return this.actual.is(':hidden');
+    },
+    toBeSelected: function() {
+      return this.actual.is(':selected');
+    },
+    toBeChecked: function() {
+      return this.actual.is(':checked');
+    },
+    toBeEmpty: function() {
+      return this.actual.is(':empty');
+    },
+    toExist: function() {
+      return this.actual.size() > 0;
+    },
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+    toHaveProp: function(propertyName, expectedPropertyValue) {
+      return hasProperty(this.actual.prop(propertyName), expectedPropertyValue);
+    },
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+    toHaveText: function(text) {
+      var trimmedText = $.trim(this.actual.text());
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(trimmedText);
+      } else {
+        return trimmedText == text;
+      }
+    },
+    toHaveValue: function(value) {
+      return this.actual.val() == value;
+    },
+    toHaveData: function(key, expectedValue) {
+      return hasProperty(this.actual.data(key), expectedValue);
+    },
+    toBe: function(selector) {
+      return this.actual.is(selector);
+    },
+    toContain: function(selector) {
+      return this.actual.find(selector).size() > 0;
+    },
+    toBeDisabled: function(selector){
+      return this.actual.is(':disabled');
+    },
+	toBeFocused: function(selector) {
+	  return this.actual.is(':focus');
+    },
+    // tests the existence of a specific event binding
+    toHandle: function(eventName) {
+      var events = this.actual.data("events");
+      return events && events[eventName].length > 0;
+    },
+    // tests the existence of a specific event binding + handler
+    toHandleWith: function(eventName, eventHandler) {
+      var stack = this.actual.data("events")[eventName];
+      var i;
+      for (i = 0; i < stack.length; i++) {
+        if (stack[i].handler == eventHandler) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+  var hasProperty = function(actualValue, expectedValue) {
+    if (expectedValue === undefined) {
+      return actualValue !== undefined;
+    }
+    return actualValue == expectedValue;
+  };
+  var bindMatcher = function(methodName) {
+    var builtInMatcher = jasmine.Matchers.prototype[methodName];
+    jasmine.JQuery.matchersClass[methodName] = function() {
+      if (this.actual
+          && (this.actual instanceof jQuery
+             || jasmine.isDomNode(this.actual))) {
+        this.actual = $(this.actual);
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        this.actual = jasmine.JQuery.elementToString(this.actual);
+        return result;
+      }
+      if (builtInMatcher) {
+        return builtInMatcher.apply(this, arguments);
+      }
+      return false;
+    };
+  };
+  for(var methodName in jQueryMatchers) {
+    bindMatcher(methodName);
+  }
+})();
+beforeEach(function() {
+  this.addMatchers(jasmine.JQuery.matchersClass);
+  this.addMatchers({
+    toHaveBeenTriggeredOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been triggered on " + selector,
+          "Expected event " + this.actual + " not to have been triggered on " + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasTriggered($(selector), this.actual);
+    }
+  });
+  this.addMatchers({
+    toHaveBeenPreventedOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been prevented on " + selector,
+          "Expected event " + this.actual + " not to have been prevented on " + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasPrevented(selector, this.actual);
+    }
+  });
+});
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+  jasmine.JQuery.events.cleanUp();
+});