decidim-dev 0.0.6

data/lib/decidim/dev/test/rspec_support/database_cleaner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean_with :truncation
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end

data/lib/decidim/dev/test/rspec_support/engine_routes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Decidim
+  # This is a quick hack so all controller specs have their engine's routes
+  # included as well as our Devise mapping.
+  module ControllerRequests
+    extend ActiveSupport::Concern
+
+    included do
+      begin
+        engine = (ENV["ENGINE_NAME"].to_s.split("-").map(&:capitalize).join("::") + "::Engine").constantize
+
+        load_routes engine if engine.respond_to?(:routes)
+      rescue NameError => _exception
+        puts "Failed to automatically inject routes for engine #{ENV["ENGINE_NAME"]}"
+      end
+    end
+
+    class_methods do
+      def load_routes(klass)
+        routes do
+          klass.routes
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Decidim::ControllerRequests, type: :controller
+
+  config.before :each, type: :controller do
+    @request.env["devise.mapping"] = Devise.mappings[:user]
+  end
+end

data/lib/decidim/dev/test/rspec_support/factory_girl.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+end

data/lib/decidim/dev/test/rspec_support/feature.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "decidim/feature_validator"
+require "decidim/comments"
+
+module Decidim
+  # Dummy engine to be able to test components.
+  class DummyEngine < Rails::Engine
+    engine_name "dummy"
+
+    routes do
+      root to: proc { [200, {}, ["DUMMY ENGINE"]] }
+      resources :dummy_resources, controller: "decidim/dummy_resources"
+    end
+  end
+
+  class DummyResource < ActiveRecord::Base
+    include HasFeature
+    include Resourceable
+    include Reportable
+    include Authorable
+    include Decidim::Comments::Commentable
+
+    feature_manifest_name "dummy"
+
+    def reported_content
+      title
+    end
+  end
+
+  class DummyResourcesController < ActionController::Base
+    helper Decidim::Comments::CommentsHelper
+    skip_authorization_check
+
+    def show
+      @commentable = DummyResource.find(params[:id])
+      render inline: %{
+        <%= display_flash_messages %>
+        <div class="reveal" id="loginModal" data-reveal></div>
+        <%= javascript_include_tag 'application' %>
+        <%= inline_comments_for(@commentable) %>
+      }
+    end
+  end
+end
+
+Decidim.register_feature(:dummy) do |feature|
+  feature.engine = Decidim::DummyEngine
+
+  feature.actions = %w(foo bar)
+
+  feature.settings(:global) do |settings|
+    settings.attribute :comments_enabled, type: :boolean, default: true
+    settings.attribute :dummy_global_attribute_1, type: :boolean
+    settings.attribute :dummy_global_attribute_2, type: :boolean
+  end
+
+  feature.settings(:step) do |settings|
+    settings.attribute :comments_blocked, type: :boolean, default: false
+    settings.attribute :dummy_step_attribute_1, type: :boolean
+    settings.attribute :dummy_step_attribute_2, type: :boolean
+  end
+
+  feature.register_resource do |resource|
+    resource.name = :dummy
+    resource.model_class_name = "Decidim::DummyResource"
+    resource.template = "decidim/dummy_resource/linked_dummys"
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    unless ActiveRecord::Base.connection.data_source_exists?("decidim_dummy_resources")
+      ActiveRecord::Migration.create_table :decidim_dummy_resources do |t|
+        t.string :title
+        t.text :address
+        t.float :latitude
+        t.float :longitude
+
+        t.references :decidim_feature, index: true
+        t.references :decidim_author, index: true
+
+        t.timestamps
+      end
+    end
+  end
+
+  config.before(:each) do
+    Decidim.find_feature_manifest(:dummy).reset_hooks!
+  end
+end

data/lib/decidim/dev/test/rspec_support/feature_context.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+RSpec.shared_context "feature" do
+  let!(:manifest_name) { raise NotImplementedError }
+  let(:manifest) { Decidim.find_feature_manifest(manifest_name) }
+
+  let!(:organization) { create(:organization) }
+
+  let(:participatory_process) do
+    create(:participatory_process, :with_steps, organization: organization)
+  end
+
+  let!(:feature) do
+    create(:feature,
+           manifest: manifest,
+           participatory_process: participatory_process)
+  end
+
+  before do
+    switch_to_host(organization.host)
+  end
+
+  def visit_feature
+    page.visit decidim.feature_path(participatory_process, feature)
+  end
+end
+
+RSpec.shared_context "feature admin" do
+  include_context "feature"
+  let(:user) { create(:user, :confirmed, organization: organization) }
+
+  before do
+    Decidim::Admin::ParticipatoryProcessUserRole.create!(
+      role: :admin,
+      user: user,
+      participatory_process: participatory_process
+    )
+
+    login_as user, scope: :user
+  end
+
+  def visit_feature_admin
+    visit decidim_admin.manage_feature_path(participatory_process, feature)
+  end
+end

data/lib/decidim/dev/test/rspec_support/geocoder.rb

@@ -0,0 +1,11 @@
+RSpec.configure do |config|
+  config.before(:each) do
+    # Set geocoder configuration in test mode
+    Decidim.geocoder = {
+      static_map_url: "http://www.example.org",
+      here_app_id: '1234',
+      here_app_code: '5678'
+    }
+    Geocoder.configure(lookup: :test)
+  end
+end

data/lib/decidim/dev/test/rspec_support/helpers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Helpers that get automatically included in feature specs.
+module Decidim::FeatureTestHelpers
+  def within_user_menu
+    within ".topbar__user__logged" do
+      find("a", text: user.name).hover
+      yield
+    end
+  end
+
+  def within_language_menu
+    within ".topbar__dropmenu.language-choose" do
+      find("ul.dropdown.menu").hover
+      yield
+    end
+  end
+
+  def click_icon(name = nil)
+    classes = ["icon"]
+    classes << ["icon--#{name}"] if name
+    find(".#{classes.join(".")}").click
+  end
+
+  def stripped(text)
+    Nokogiri::HTML(text).text
+  end
+
+  def within_flash_messages
+    within ".flash.callout" do
+      yield
+    end
+  end
+
+  def expect_user_logged
+    expect(page).to have_css(".topbar__user__logged")
+  end
+end
+
+def stripped(text)
+  Nokogiri::HTML(text).text
+end
+
+RSpec.configure do |config|
+  config.include Decidim::FeatureTestHelpers, type: :feature
+end

data/lib/decidim/dev/test/rspec_support/html_matchers.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "rspec-html-matchers"
+
+RSpec.configure do |config|
+  config.include RSpecHtmlMatchers
+end

data/lib/decidim/dev/test/rspec_support/i18n.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+RSpec.configure do |config|
+  config.before(:suite) do
+    I18n.config.enforce_available_locales = false
+  end
+
+  config.around(:each) do |example|
+    I18n.available_locales = %w{en ca es}
+    Decidim.available_locales = %w{en ca es}
+
+    previous_locale = I18n.locale
+    example.run
+    I18n.locale = previous_locale
+  end
+end

data/lib/decidim/dev/test/rspec_support/phantomjs_polyfills/bind-polyfill.js

@@ -0,0 +1,18 @@
+if (typeof Function.prototype.bind != 'function') {
+    Function.prototype.bind = function bind(obj) {
+        var args = Array.prototype.slice.call(arguments, 1),
+            self = this,
+            nop = function() {
+            },
+            bound = function() {
+                return self.apply(
+                    this instanceof nop ? this : (obj || {}), args.concat(
+                        Array.prototype.slice.call(arguments)
+                    )
+                );
+            };
+        nop.prototype = this.prototype || {};
+        bound.prototype = new nop();
+        return bound;
+    };
+}

data/lib/decidim/dev/test/rspec_support/phantomjs_polyfills/object-assign-polyfill.js

@@ -0,0 +1,24 @@
+//https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill
+if (typeof Object.assign != 'function') {
+  (function () {
+    Object.assign = function (target) {
+      'use strict';
+      if (target === undefined || target === null) {
+        throw new TypeError('Cannot convert undefined or null to object');
+      }
+
+      var output = Object(target);
+      for (var index = 1; index < arguments.length; index++) {
+        var source = arguments[index];
+        if (source !== undefined && source !== null) {
+          for (var nextKey in source) {
+            if (source.hasOwnProperty(nextKey)) {
+              output[nextKey] = source[nextKey];
+            }
+          }
+        }
+      }
+      return output;
+    };
+  })();
+}

data/lib/decidim/dev/test/rspec_support/phantomjs_polyfills/promise.js

@@ -0,0 +1,233 @@
+(function (root) {
+
+  // Store setTimeout reference so promise-polyfill will be unaffected by
+  // other code modifying setTimeout (like sinon.useFakeTimers())
+  var setTimeoutFunc = setTimeout;
+
+  function noop() {}
+  
+  // Polyfill for Function.prototype.bind
+  function bind(fn, thisArg) {
+    return function () {
+      fn.apply(thisArg, arguments);
+    };
+  }
+
+  function Promise(fn) {
+    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
+    if (typeof fn !== 'function') throw new TypeError('not a function');
+    this._state = 0;
+    this._handled = false;
+    this._value = undefined;
+    this._deferreds = [];
+
+    doResolve(fn, this);
+  }
+
+  function handle(self, deferred) {
+    while (self._state === 3) {
+      self = self._value;
+    }
+    if (self._state === 0) {
+      self._deferreds.push(deferred);
+      return;
+    }
+    self._handled = true;
+    Promise._immediateFn(function () {
+      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+        return;
+      }
+      var ret;
+      try {
+        ret = cb(self._value);
+      } catch (e) {
+        reject(deferred.promise, e);
+        return;
+      }
+      resolve(deferred.promise, ret);
+    });
+  }
+
+  function resolve(self, newValue) {
+    try {
+      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then;
+        if (newValue instanceof Promise) {
+          self._state = 3;
+          self._value = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === 'function') {
+          doResolve(bind(then, newValue), self);
+          return;
+        }
+      }
+      self._state = 1;
+      self._value = newValue;
+      finale(self);
+    } catch (e) {
+      reject(self, e);
+    }
+  }
+
+  function reject(self, newValue) {
+    self._state = 2;
+    self._value = newValue;
+    finale(self);
+  }
+
+  function finale(self) {
+    if (self._state === 2 && self._deferreds.length === 0) {
+      Promise._immediateFn(function() {
+        if (!self._handled) {
+          Promise._unhandledRejectionFn(self._value);
+        }
+      });
+    }
+
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+      handle(self, self._deferreds[i]);
+    }
+    self._deferreds = null;
+  }
+
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
+
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, self) {
+    var done = false;
+    try {
+      fn(function (value) {
+        if (done) return;
+        done = true;
+        resolve(self, value);
+      }, function (reason) {
+        if (done) return;
+        done = true;
+        reject(self, reason);
+      });
+    } catch (ex) {
+      if (done) return;
+      done = true;
+      reject(self, ex);
+    }
+  }
+
+  Promise.prototype['catch'] = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    var prom = new (this.constructor)(noop);
+
+    handle(this, new Handler(onFulfilled, onRejected, prom));
+    return prom;
+  };
+
+  Promise.all = function (arr) {
+    var args = Array.prototype.slice.call(arr);
+
+    return new Promise(function (resolve, reject) {
+      if (args.length === 0) return resolve([]);
+      var remaining = args.length;
+
+      function res(i, val) {
+        try {
+          if (val && (typeof val === 'object' || typeof val === 'function')) {
+            var then = val.then;
+            if (typeof then === 'function') {
+              then.call(val, function (val) {
+                res(i, val);
+              }, reject);
+              return;
+            }
+          }
+          args[i] = val;
+          if (--remaining === 0) {
+            resolve(args);
+          }
+        } catch (ex) {
+          reject(ex);
+        }
+      }
+
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
+
+  Promise.resolve = function (value) {
+    if (value && typeof value === 'object' && value.constructor === Promise) {
+      return value;
+    }
+
+    return new Promise(function (resolve) {
+      resolve(value);
+    });
+  };
+
+  Promise.reject = function (value) {
+    return new Promise(function (resolve, reject) {
+      reject(value);
+    });
+  };
+
+  Promise.race = function (values) {
+    return new Promise(function (resolve, reject) {
+      for (var i = 0, len = values.length; i < len; i++) {
+        values[i].then(resolve, reject);
+      }
+    });
+  };
+
+  // Use polyfill for setImmediate for performance gains
+  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||
+    function (fn) {
+      setTimeoutFunc(fn, 0);
+    };
+
+  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+    if (typeof console !== 'undefined' && console) {
+      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+    }
+  };
+
+  /**
+   * Set the immediate function to execute callbacks
+   * @param fn {function} Function to execute
+   * @deprecated
+   */
+  Promise._setImmediateFn = function _setImmediateFn(fn) {
+    Promise._immediateFn = fn;
+  };
+
+  /**
+   * Change the function to execute on unhandled rejection
+   * @param {function} fn Function to execute on unhandled rejection
+   * @deprecated
+   */
+  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+    Promise._unhandledRejectionFn = fn;
+  };
+  
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = Promise;
+  } else if (!root.Promise) {
+    root.Promise = Promise;
+  }
+
+})(this);