foreman_webhooks 0.0.1

data/db/migrate/20191016100128_create_webhook_targets.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class CreateWebhookTargets < ActiveRecord::Migration[5.2]
+  def change
+    create_table :webhook_targets do |t|
+      t.string :name, null: false
+      t.string :target_url, null: false
+      t.string :events, null: false, array: true, index: true
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20200831194208_rename_webhook_targets_to_webhooks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RenameWebhookTargetsToWebhooks < ActiveRecord::Migration[6.0]
+  def change
+    rename_table :webhook_targets, :webhooks
+  end
+end

data/db/migrate/20200831194514_add_template_to_webhooks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddTemplateToWebhooks < ActiveRecord::Migration[6.0]
+  def change
+    add_reference :webhooks, :webhook_template, foreign_key: { to_table: :templates }
+  end
+end

data/db/migrate/20200907232758_rename_webhook_permissions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class RenameWebhookPermissions < ActiveRecord::Migration[6.0]
+  PERMISSIONS = {
+    'view_webhook_targets' => 'view_webhooks',
+    'create_webhook_targets' => 'create_webhooks',
+    'edit_webhook_targets' => 'edit_webhooks',
+    'destroy_webhook_targets' => 'destroy_webhooks'
+  }.freeze
+
+  def up
+    PERMISSIONS.each do |from, to|
+      Permission.unscoped.find_by(name: from)&.update_columns(name: to)
+    end
+  end
+
+  def down
+    PERMISSIONS.each do |from, to|
+      Permission.unscoped.find_by(name: to)&.update_columns(name: from)
+    end
+  end
+end

data/db/migrate/20200908004234_add_columns_to_webhooks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddColumnsToWebhooks < ActiveRecord::Migration[6.0]
+  def change
+    add_column :webhooks, :http_method, :string, default: 'POST', null: false
+    add_column :webhooks, :http_content_type, :string, default: 'application/json', null: false
+    add_column :webhooks, :enabled, :boolean, default: true
+    add_column :webhooks, :verify_ssl, :boolean, default: true
+    add_column :webhooks, :ssl_ca_file, :text, null: true
+    add_column :webhooks, :user, :string, null: true
+    add_column :webhooks, :password, :text, null: true
+  end
+end

data/db/migrate/20201014115147_rename_ca_file_column.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RenameCaFileColumn < ActiveRecord::Migration[6.0]
+  def change
+    rename_column :webhooks, :ssl_ca_file, :ssl_ca_certs
+  end
+end

data/db/migrate/20201109135301_add_http_headers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddHttpHeaders < ActiveRecord::Migration[6.0]
+  def change
+    # HTTP headers stored as JSON: {"header_name": "value"}
+    add_column :webhooks, :http_headers, :text, null: true
+  end
+end

data/db/seeds.d/95_webhook_templates.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+WebhookTemplate.without_auditing do
+  SeedHelper.import_templates(
+    Dir[File.join("#{ForemanWebhooks::Engine.root}/app/views/foreman_webhooks/webhook_templates/**/*.erb")]
+  )
+end

data/lib/foreman_webhooks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'foreman_webhooks/engine'
+
+module ForemanWebhooks
+end

data/lib/foreman_webhooks/engine.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  class Engine < ::Rails::Engine
+    engine_name 'foreman_webhooks'
+
+    config.autoload_paths += Dir["#{config.root}/app/jobs"]
+
+    # Add any db migrations
+    initializer 'foreman_webhooks.load_app_instance_data' do |app|
+      ForemanWebhooks::Engine.paths['db/migrate'].existent.each do |path|
+        app.config.paths['db/migrate'] << path
+      end
+    end
+
+    initializer 'foreman_webhooks.register_plugin', before: :finisher_hook do |_app|
+      Foreman::Plugin.register :foreman_webhooks do
+        requires_foreman '>= 2.3'
+
+        apipie_documented_controllers ["#{ForemanWebhooks::Engine.root}/app/controllers/api/v2/*.rb"]
+        ApipieDSL.configuration.sections += ['webhooks']
+        ApipieDSL.configuration.dsl_classes_matchers += [
+          "#{ForemanWebhooks::Engine.root}/app/lib/foreman_webhooks/renderer/**/*.rb"
+        ]
+
+        register_global_js_file 'routes'
+
+        # Add permissions
+        security_block :foreman_webhooks do
+          permission :view_webhooks,    { webhooks: %i[index show auto_complete_search],
+                                          'api/v2/webhooks': %i[index show] }, resource_type: 'Webhook'
+          permission :create_webhooks,  { webhooks: %i[new create],
+                                          'api/v2/webhooks': [:create] }, resource_type: 'Webhook'
+          permission :edit_webhooks,    { webhooks: %i[edit update],
+                                          'api/v2/webhooks': [:update] }, resource_type: 'Webhook'
+          permission :destroy_webhooks, { webhooks: [:destroy],
+                                          'api/v2/webhooks': [:destroy] }, resource_type: 'Webhook'
+          permission :view_webhook_templates,     { webhook_templates: %i[index show auto_complete_search preview export],
+                                                    'api/v2/webhook_templates': %i[index show export] },
+                     resource_type: 'WebhookTemplate'
+          permission :create_webhook_templates,   { webhook_templates: %i[new create clone_template],
+                                                    'api/v2/webhook_templates': %i[create clone import] },
+                     resource_type: 'WebhookTemplate'
+          permission :edit_webhook_templates,     { webhook_templates: %i[edit update],
+                                                    'api/v2/webhook_templates': %i[update import] },
+                     resource_type: 'WebhookTemplate'
+          permission :destroy_webhook_templates,  { webhook_templates: [:destroy],
+                                                    'api/v2/webhook_templates': [:destroy] },
+                     resource_type: 'WebhookTemplate'
+          permission :lock_webhook_templates,     { webhook_templates: %i[lock unlock],
+                                                    'api/v2/webhook_templates': %i[lock unlock] },
+                     resource_type: 'WebhookTemplate'
+        end
+
+        # add menu entry
+        divider :admin_menu, caption: N_('Webhook'), parent: :administer_menu
+        menu :admin_menu, :webhooks, url: '/webhooks',
+                                     url_hash: { controller: :webhooks, action: :index },
+                                     caption: N_('Webhooks'),
+                                     parent: :administer_menu
+        menu :admin_menu, :webhook_templates, url_hash: { controller: :webhook_templates, action: :index },
+                                              caption: N_('Webhook Templates'),
+                                              parent: :administer_menu
+
+        # add helpers to safe-mode
+        allowed_template_helpers :payload
+
+        # subscribe to all events
+        subscribe(/.event.foreman$/, ::ForemanWebhooks::EventSubscriber)
+      end
+    end
+
+    # Include concerns in this config.to_prepare block
+    config.to_prepare do
+    # Host::Managed.send(:include, ForemanWebhooks::HostExtensions)
+    rescue StandardError => e
+      Rails.logger.warn "ForemanWebhooks: skipping engine hook (#{e})"
+    end
+  end
+end

data/lib/foreman_webhooks/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  VERSION = '0.0.1'
+end

data/lib/tasks/foreman_webhooks_tasks.rake

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+# Tasks
+namespace :foreman_webhooks do
+  namespace :example do
+    desc 'Example Task'
+    task task: :environment do
+      # Task goes here
+    end
+  end
+end
+
+# Tests
+namespace :test do
+  desc 'Test ForemanWebhooks'
+  Rake::TestTask.new(:foreman_webhooks) do |t|
+    test_dir = File.join(File.dirname(__FILE__), '../..', 'test')
+    t.libs << ['test', test_dir]
+    t.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+    t.warning = false
+  end
+end
+
+namespace :foreman_webhooks do
+  task :rubocop do
+    begin
+      require 'rubocop/rake_task'
+      RuboCop::RakeTask.new(:rubocop_foreman_webhooks) do |task|
+        task.patterns = ["#{ForemanWebhooks::Engine.root}/app/**/*.rb",
+                         "#{ForemanWebhooks::Engine.root}/lib/**/*.rb",
+                         "#{ForemanWebhooks::Engine.root}/test/**/*.rb"]
+      end
+    rescue StandardError
+      puts 'Rubocop not loaded.'
+    end
+
+    Rake::Task['rubocop_foreman_webhooks'].invoke
+  end
+end
+
+Rake::Task[:test].enhance ['test:foreman_webhooks']
+
+load 'tasks/jenkins.rake'
+Rake::Task['jenkins:unit'].enhance ['test:foreman_webhooks', 'foreman_webhooks:rubocop'] if Rake::Task.task_defined?(:'jenkins:unit')

data/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "foreman_webhooks",
+  "version": "0.0.1",
+  "description": "This plugins allows to configure Webhooks for Foreman.",
+  "main": "index.js",
+  "scripts": {
+    "lint": "tfm-lint --plugin -d /webpack",
+    "test": "tfm-test --plugin",
+    "test:watch": "tfm-test --plugin --watchAll",
+    "test:current": "tfm-test --plugin --watch",
+    "publish-coverage": "tfm-publish-coverage",
+    "stories": "tfm-stories --plugin",
+    "stories:build": "tfm-build-stories --plugin",
+    "create-react-component": "yo react-domain"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theforeman/foreman_webhooks.git"
+  },
+  "bugs": {
+    "url": "https://projects.theforeman.org/projects/webhooks/issues"
+  },
+  "peerDependencies": {
+    "@theforeman/vendor": ">= 4.15.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.7.0",
+    "@theforeman/builder": "^4.15.1",
+    "@theforeman/stories": "^4.15.1",
+    "@theforeman/test": "^4.15.1",
+    "@theforeman/vendor-dev": "^4.15.1",
+    "@theforeman/eslint-plugin-foreman": "^4.15.1",
+    "babel-eslint": "^10.0.0",
+    "eslint": "^6.8.0",
+    "eslint-plugin-spellcheck": "^0.0.17",
+    "prettier": "^1.13.5",
+    "stylelint": "^9.3.0",
+    "stylelint-config-standard": "^18.0.0",
+    "surge": "^0.20.3"
+  },
+  "dependencies": {
+    "jed": "^1.1.1",
+    "react-intl": "^2.8.0"
+  }
+}

data/test/controllers/api/v2/webhook_templates_controller_test.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class Api::V2::WebhookTemplatesControllerTest < ActionController::TestCase
+  valid_attrs = { name: 'webhook_template_test', template: 'a,b,c' }
+
+  def setup
+    @webhook_template = FactoryBot.create(:webhook_template)
+  end
+
+  let(:webhook_template) { FactoryBot.create(:webhook_template) }
+
+  test 'should get index' do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:webhook_templates)
+    webhook_templates = ActiveSupport::JSON.decode(@response.body)
+    assert !webhook_templates.empty?
+    template = webhook_templates['results'].find { |h| h['id'] == @webhook_template.id }
+    assert_equal @webhook_template.name, template['name']
+  end
+
+  test 'should show individual record' do
+    get :show, params: { id: @webhook_template.to_param }
+    assert_response :success
+    show_response = ActiveSupport::JSON.decode(@response.body)
+    assert !show_response.empty?
+    assert_equal @webhook_template['template'], show_response['template']
+  end
+
+  test 'should create webhook_template' do
+    assert_difference('WebhookTemplate.unscoped.count') do
+      post :create, params: { webhook_template: valid_attrs }
+    end
+    assert_response :created
+    response = JSON.parse(@response.body)
+    assert response.key?('name')
+    assert response.key?('template')
+    assert_equal response['name'], valid_attrs[:name]
+    assert_equal response['template'], valid_attrs[:template]
+  end
+
+  test 'create with template length' do
+    valid_params = valid_attrs.merge(template: RFauxFactory.gen_alpha(5000))
+    assert_difference('WebhookTemplate.unscoped.count') do
+      post :create, params: { webhook_template: valid_params }
+    end
+    assert_response :created
+    response = JSON.parse(@response.body)
+    assert response.key?('template')
+    assert_equal response['template'], valid_params[:template]
+  end
+
+  test 'create with one character name' do
+    valid_params = valid_attrs.merge(name: RFauxFactory.gen_alpha(1))
+    assert_difference('WebhookTemplate.unscoped.count') do
+      post :create, params: { webhook_template: valid_params }
+    end
+    assert_response :created
+    response = JSON.parse(@response.body)
+    assert response.key?('name')
+    assert_equal response['name'], valid_params[:name]
+  end
+
+  test 'should create webhook_template with organization' do
+    organization_id = Organization.first.id
+    assert_difference('WebhookTemplate.unscoped.count') do
+      post :create, params: { webhook_template: valid_attrs.merge(organization_ids: [organization_id]) }
+    end
+    assert_response :created
+    response = JSON.parse(@response.body)
+    assert response.key?('organizations')
+    organization_ids = response['organizations'].map { |org| org['id'] }
+    assert_equal organization_ids.length, 1
+    assert_include organization_ids, organization_id
+  end
+
+  test 'should update name' do
+    new_name = 'new webhook_template name'
+    put :update, params: { id: @webhook_template.id, webhook_template: { name: new_name } }
+    assert_response :success
+    response = JSON.parse(@response.body)
+    assert response.key?('name')
+    assert_equal response['name'], new_name
+  end
+
+  test 'should update template' do
+    new_template = 'new webhook_template template'
+    put :update, params: { id: @webhook_template.id, webhook_template: { template: new_template } }
+    assert_response :success
+    response = JSON.parse(@response.body)
+    assert response.key?('template')
+    assert_equal response['template'], new_template
+  end
+
+  test 'should not create with invalid name' do
+    assert_difference('WebhookTemplate.unscoped.count', 0) do
+      post :create, params: { webhook_template: valid_attrs.merge(name: '') }
+    end
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not create with invalid template' do
+    assert_difference('WebhookTemplate.unscoped.count', 0) do
+      post :create, params: { webhook_template: valid_attrs.merge(template: '') }
+    end
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not update with invalid name' do
+    put :update, params: { id: @webhook_template.id, webhook_template: { name: '' } }
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not update with invalid template' do
+    put :update, params: { id: @webhook_template.id, webhook_template: { template: '' } }
+    assert_response :unprocessable_entity
+  end
+
+  test 'search webhook_template' do
+    get :index, params: { search: @webhook_template.name, format: 'json' }
+    assert_response :success, "search webhook_template name: '#{@webhook_template.name}'" \
+                              " failed with code: #{@response.code}"
+    response = JSON.parse(@response.body)
+    assert_equal response['results'].length, 1
+    assert_equal response['results'][0]['id'], @webhook_template.id
+  end
+
+  test 'search webhook_template by name and organization' do
+    org = Organization.first
+    @webhook_template.organizations = [org]
+    assert @webhook_template.save
+    get :index, params: { search: @webhook_template.name, organization_id: org.id, format: 'json' }
+    assert_response :success, "search webhook_template by name and organization failed with code: #{@response.code}"
+    response = JSON.parse(@response.body)
+    assert_equal response['results'].length, 1
+    assert_equal response['results'][0]['id'], @webhook_template.id
+  end
+
+  test "should created webhook_template with unwrapped 'template'" do
+    assert_difference('WebhookTemplate.unscoped.count') do
+      post :create, params: valid_attrs
+    end
+    assert_response :created
+  end
+
+  test 'should update webhook_template' do
+    put :update, params: { id: @webhook_template.to_param, webhook_template: valid_attrs }
+    assert_response :success
+  end
+
+  test 'should destroy webhook_template' do
+    assert_difference('WebhookTemplate.unscoped.count', -1) do
+      delete :destroy, params: { id: @webhook_template.to_param }
+    end
+    assert_response :success
+  end
+
+  test 'should add audit comment' do
+    WebhookTemplate.auditing_enabled = true
+    WebhookTemplate.any_instance.stubs(:valid?).returns(true)
+    webhook_template = FactoryBot.create(:webhook_template)
+    put :update, params: { id: webhook_template.to_param,
+                           webhook_template: { audit_comment: 'aha', template: 'tmp' } }
+    assert_response :success
+    assert_equal 'aha', webhook_template.audits.last.comment
+  end
+
+  test 'should clone template' do
+    original_webhook_template = FactoryBot.create(:webhook_template)
+    post :clone, params: { id: original_webhook_template.to_param,
+                           webhook_template: { name: 'MyClone' } }
+    assert_response :success
+    template = ActiveSupport::JSON.decode(@response.body)
+    assert_equal(template['name'], 'MyClone')
+    assert_equal(template['template'], original_webhook_template.template)
+    refute_equal(template['id'], original_webhook_template.id)
+  end
+
+  test 'export should export the erb of the template' do
+    get :export, params: { id: webhook_template.to_param }
+    assert_response :success
+    assert_equal 'text/plain', response.media_type
+    assert_equal webhook_template.to_erb, response.body
+  end
+
+  test 'clone name should not be blank' do
+    post :clone, params: { id: FactoryBot.create(:webhook_template).to_param,
+                           webhook_template: { name: '' } }
+    assert_response :unprocessable_entity
+  end
+
+  test 'should import webhook template' do
+    webhook_template = FactoryBot.create(:webhook_template, template: 'a')
+    post :import, params: { webhook_template: { name: webhook_template.name, template: 'b' } }
+    assert_response :success
+    assert_equal 'b', WebhookTemplate.unscoped.find_by_name(webhook_template.name).template
+  end
+end