+

+  it "is valid with put-your-key-here or your-key" do

+    agent.options['api_key'] = 'put-your-key-here'

+    expect(agent).to be_valid

+    expect(agent.working?).to be_falsey

+

+    agent.options['api_key'] = 'your-key'

+    expect(agent).to be_valid

+    expect(agent.working?).to be_falsey

+  end

+    it 'should respond with interpolated response message if configured with `response` option' do

+      agent.options['response'] = '{{some_key.people[1].name}}'

+      out = agent.receive_web_request({ 'secret' => 'foobar', 'some_key' => payload }, "post", "text/html")

+      expect(out).to eq(['jon', 201])

+    end

+

+    it 'should respond with customized response code if configured with `code` option' do

+      agent.options['code'] = '200'

+      out = agent.receive_web_request({ 'secret' => 'foobar', 'some_key' => payload }, "post", "text/html")

+      expect(out).to eq(['Event Created', 200])

+    end

+

+    it 'should respond with `201` if the code option is empty, nil or missing' do

+      agent.options['code'] = ''

+      out = agent.receive_web_request({ 'secret' => 'foobar', 'some_key' => payload }, "post", "text/html")

+      expect(out).to eq(['Event Created', 201])

+      

+      agent.options['code'] = nil

+      out = agent.receive_web_request({ 'secret' => 'foobar', 'some_key' => payload }, "post", "text/html")

+      expect(out).to eq(['Event Created', 201])

+

+      agent.options.delete('code')

+      out = agent.receive_web_request({ 'secret' => 'foobar', 'some_key' => payload }, "post", "text/html")

+      expect(out).to eq(['Event Created', 201])

+    end

+

+        expect { @checker.check }.to change { Event.count }.by(8)

+        @events = Event.last(8)

+

+      it "should check url with unescaped brackets in the path component" do

+        event = @events[7]

+        expect(event.payload['url']).to eq("http://[::1]/path%5B%5D?query[]=foo")

+      end

+

+

+

+  describe 'omniauth options provider registry for non-conforming omniauth responses' do

+    describe '.register_options_provider' do

+      before do

+        Service.register_options_provider('test-omniauth-provider') do |omniauth|

+          { name: omniauth['special_field'] }

+        end

+      end

+

+      after do

+        Service.option_providers.delete('test-omniauth-provider')

+      end

+

+      it 'allows gem developers to add their own options provider to the registry' do

+        actual_options = Service.get_options({

+          'provider' => 'test-omniauth-provider',

+          'special_field' => 'A Great Name'

+        })

+

+        expect(actual_options[:name]).to eq('A Great Name')

+      end

+    end

+  end

+  let(:bob) { users(:bob) }

+

+

+  context '#undefined_agent_types' do

+    it 'returns an empty array when no agents are undefined' do

+      expect(bob.undefined_agent_types).to be_empty

+    end

+

+    it 'returns the undefined agent types' do

+      agent = agents(:bob_website_agent)

+      agent.update_attribute(:type, 'Agents::UndefinedAgent')

+      expect(bob.undefined_agent_types).to match_array(['Agents::UndefinedAgent'])

+    end

+  end

+

+  context '#undefined_agents' do

+    it 'returns an empty array when no agents are undefined' do

+      expect(bob.undefined_agents).to be_empty

+    end

+

+    it 'returns the undefined agent types' do

+      agent = agents(:bob_website_agent)

+      agent.update_attribute(:type, 'Agents::UndefinedAgent')

+      expect(bob.undefined_agents).not_to be_empty

+      expect(bob.undefined_agents.first).to be_a(Agent)

+    end

+  end

+WebMock.disable_net_connect!(allow_localhost: true)

+  config.include Devise::Test::ControllerHelpers, type: :controller

+  let(:event) { Event.new(user: @checker.user, payload: {'file_pointer' => {'file' => 'text.txt', 'agent_id' => @checker.id}}) }

+

+    event.payload['file_pointer']['agent_id'] = @checker2.id

+

+  context '#has_file_pointer?' do

+    it 'returns true if the event contains a file pointer' do

+      expect(@checker.has_file_pointer?(event)).to be_truthy

+    end

+

+    it 'returns false if the event does not contain a file pointer' do

+      expect(@checker.has_file_pointer?(Event.new)).to be_falsy

+    end

+  end

+

+  it '#get_upload_io returns a Faraday::UploadIO instance' do

+    io_mock = mock()

+    mock(@checker).get_io(event) { StringIO.new("testdata") }

+

+    upload_io = @checker.get_upload_io(event)

+    expect(upload_io).to be_a(Faraday::UploadIO)

+    expect(upload_io.content_type).to eq('text/plain')

+  end

+end

+/**

+ * jQuery serializeObject

+ * @copyright 2014, macek <paulmacek@gmail.com>

+ * @link https://github.com/macek/jquery-serialize-object

+ * @license BSD

+ * @version 2.5.0

+ */

+(function(root, factory) {

+

+  // AMD

+  if (typeof define === "function" && define.amd) {

+    define(["exports", "jquery"], function(exports, $) {

+      return factory(exports, $);

+    });

+  }

+

+  // CommonJS

+  else if (typeof exports !== "undefined") {

+    var $ = require("jquery");

+    factory(exports, $);

+  }

+

+  // Browser

+  else {

+    factory(root, (root.jQuery || root.Zepto || root.ender || root.$));

+  }

+

+}(this, function(exports, $) {

+

+  var patterns = {

+    validate: /^[a-z_][a-z0-9_]*(?:\[(?:\d*|[a-z0-9_]+)\])*$/i,

+    key:      /[a-z0-9_]+|(?=\[\])/gi,

+    push:     /^$/,

+    fixed:    /^\d+$/,

+    named:    /^[a-z0-9_]+$/i

+  };

+

+  function FormSerializer(helper, $form) {

+

+    // private variables

+    var data     = {},

+        pushes   = {};

+

+    // private API

+    function build(base, key, value) {

+      base[key] = value;

+      return base;

+    }

+

+    function makeObject(root, value) {

+

+      var keys = root.match(patterns.key), k;

+

+      // nest, nest, ..., nest

+      while ((k = keys.pop()) !== undefined) {

+        // foo[]

+        if (patterns.push.test(k)) {

+          var idx = incrementPush(root.replace(/\[\]$/, ''));

+          value = build([], idx, value);

+        }

+

+        // foo[n]

+        else if (patterns.fixed.test(k)) {

+          value = build([], k, value);

+        }

+

+        // foo; foo[bar]

+        else if (patterns.named.test(k)) {

+          value = build({}, k, value);

+      return value;

+    }

+

+    function incrementPush(key) {

+      if (pushes[key] === undefined) {

+        pushes[key] = 0;

+      }

+      return pushes[key]++;

+    }

+

+    function encode(pair) {

+      switch ($('[name="' + pair.name + '"]', $form).attr("type")) {

+        case "checkbox":

+          return pair.value === "on" ? true : pair.value;

+        default:

+          return pair.value;

+      }

+    }

+

+    function addPair(pair) {

+      if (!patterns.validate.test(pair.name)) return this;

+      var obj = makeObject(pair.name, encode(pair));

+      data = helper.extend(true, data, obj);

+      return this;

+    }

+

+    function addPairs(pairs) {

+      if (!helper.isArray(pairs)) {

+        throw new Error("formSerializer.addPairs expects an Array");

+      }

+      for (var i=0, len=pairs.length; i<len; i++) {

+        this.addPair(pairs[i]);

+      }

+      return this;

+    }

+

+    function serialize() {

+      return data;

+    }

+

+    function serializeJSON() {

+      return JSON.stringify(serialize());

+    }

+

+    // public API

+    this.addPair = addPair;

+    this.addPairs = addPairs;

+    this.serialize = serialize;

+    this.serializeJSON = serializeJSON;

+  }

+

+  FormSerializer.patterns = patterns;

+

+  FormSerializer.serializeObject = function serializeObject() {

+    return new FormSerializer($, this).

+      addPairs(this.serializeArray()).

+      serialize();

+  };

+

+  FormSerializer.serializeJSON = function serializeJSON() {

+    return new FormSerializer($, this).

+      addPairs(this.serializeArray()).

+      serializeJSON();

+

+  if (typeof $.fn !== "undefined") {

+    $.fn.serializeObject = FormSerializer.serializeObject;

+    $.fn.serializeJSON   = FormSerializer.serializeJSON;

+  }

+

+  exports.FormSerializer = FormSerializer;

+

+  return FormSerializer;

+}));