foreman_webhooks 0.0.1

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class Api::V2::WebhooksControllerTest < ActionController::TestCase
+  valid_attrs = { name: 'webhook_test', event: 'host_created.event.foreman',
+                  target_url: 'https://app.example.com' }
+
+  def setup
+    @webhook = FactoryBot.create(:webhook)
+    @webhook_template = FactoryBot.create(:webhook_template)
+  end
+
+  let(:webhook) { FactoryBot.create(:webhook) }
+
+  test 'should get index' do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:webhooks)
+    webhooks = ActiveSupport::JSON.decode(@response.body)
+    assert !webhooks.empty?
+    webhook = webhooks['results'].find { |h| h['id'] == @webhook.id }
+    assert_equal @webhook.name, webhook['name']
+  end
+
+  test 'should show individual record' do
+    get :show, params: { id: @webhook.to_param }
+    assert_response :success
+    show_response = ActiveSupport::JSON.decode(@response.body)
+    assert !show_response.empty?
+    assert_equal @webhook.event, show_response['event']
+  end
+
+  test 'should create webhook' do
+    assert_difference('Webhook.unscoped.count') do
+      post :create, params: { webhook: valid_attrs.merge(webhook_template_id: @webhook_template.id) }
+    end
+    assert_response :created
+    response = JSON.parse(@response.body)
+    assert response.key?('name')
+    assert response.key?('event')
+    assert_equal response['name'], valid_attrs[:name]
+    assert_equal response['event'], valid_attrs[:event]
+  end
+
+  test 'should update name' do
+    new_name = 'new webhook name'
+    put :update, params: { id: @webhook.id, webhook: { 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 event' do
+    new_event = 'subnet_created.event.foreman'
+    put :update, params: { id: @webhook.id, webhook: { event: new_event } }
+    assert_response :success
+    response = JSON.parse(@response.body)
+    assert response.key?('event')
+    assert_equal response['event'], new_event
+  end
+
+  test 'should not create with invalid name' do
+    assert_difference('Webhook.unscoped.count', 0) do
+      post :create, params: { webhook: valid_attrs.merge(name: '') }
+    end
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not create with invalid event' do
+    assert_difference('Webhook.unscoped.count', 0) do
+      post :create, params: { webhook: valid_attrs.merge(event: '') }
+    end
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not update with invalid name' do
+    put :update, params: { id: @webhook.id, webhook: { name: '' } }
+    assert_response :unprocessable_entity
+  end
+
+  test 'should not update with invalid event' do
+    put :update, params: { id: @webhook.id, webhook: { event: '' } }
+    assert_response :unprocessable_entity
+  end
+
+  test 'search webhook' do
+    get :index, params: { search: @webhook.name, format: 'json' }
+    assert_response :success, "search webhook name: '#{@webhook.name}'" \
+                              " failed with code: #{@response.code}"
+    response = JSON.parse(@response.body)
+    assert_equal response['results'].length, 1
+    assert_equal response['results'][0]['id'], @webhook.id
+  end
+
+  test 'should update webhook' do
+    put :update, params: { id: @webhook.to_param, webhook: valid_attrs }
+    assert_response :success
+  end
+
+  test 'should destroy webhook' do
+    assert_difference('Webhook.unscoped.count', -1) do
+      delete :destroy, params: { id: @webhook.to_param }
+    end
+    assert_response :success
+  end
+end

data/test/factories/webhook.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :webhook do
+    sequence(:name) { |n| "Webhook #{n}" }
+    target_url { 'https://hook.example.com/api/callback' }
+    event { 'subnet_created.event.foreman' }
+    enabled { true }
+    webhook_template
+
+    trait :with_template do
+      transient do
+        template { 'template content' }
+      end
+      after(:build) do |webhook, evaluator|
+        webhook.webhook_template = FactoryBot.create(:webhook_template, template: evaluator.template)
+      end
+    end
+  end
+end

data/test/factories/webhook_target.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :webhook_target do
+    sequence(:name) { |n| "Webhook Target #{n}" }
+    target_url { 'https://hook.example.com/api/callback' }
+    events { ['subnet_created.event.foreman'] }
+  end
+end

data/test/factories/webhook_template.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :webhook_template do
+    sequence(:name) { |n| "webhook_template#{n}" }
+    sequence(:template) { |n| "template content #{n}" }
+
+    trait :snippet do
+      snippet { true }
+    end
+
+    trait :locked do
+      locked { true }
+    end
+  end
+end

data/test/jobs/foreman_webhooks/deliver_webhook_job_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module ForemanWebhooks
+  class DeliverWebhookJobTest < ActiveJob::TestCase
+    let(:webhook) { FactoryBot.create(:webhook) }
+    let(:job) do
+      ::ForemanWebhooks::DeliverWebhookJob.new(event_name: 'subnet_created', payload: { id: 2 }, webhook_id: webhook.id)
+    end
+
+    it 'executes the webhook service' do
+      ::ForemanWebhooks::WebhookService.any_instance.expects(:execute).once
+      job.perform_now
+    end
+  end
+end

data/test/models/webhook_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module ForemanWebhooks
+  class WebhookServiceTest < ActiveSupport::TestCase
+    def setup
+      User.current = users(:admin)
+    end
+
+    let(:webhook) { FactoryBot.create(:webhook) }
+    let(:webhook_template) { FactoryBot.create(:webhook_template) }
+
+    test 'password is saved encrypted when created' do
+      Webhook.any_instance.expects(:encryption_key).at_least_once.returns('25d224dd383e92a7e0c82b8bf7c985e815f34cf5')
+      webhook = Webhook.new(
+        name: 'new12345', target_url: 'https://app.example.com',
+        user: 'username', password: 'abcdef', events: 'host_created.event.foreman',
+        webhook_template_id: webhook_template.id
+      )
+      as_admin do
+        assert webhook.save!
+      end
+      assert_equal webhook.password, 'abcdef'
+      refute_equal webhook.password_in_db, 'abcdef'
+    end
+
+    test 'password is saved encrypted when updated' do
+      webhook.expects(:encryption_key).at_least_once.returns('25d224dd383e92a7e0c82b8bf7c985e815f34cf5')
+      webhook.password = '123456'
+      as_admin do
+        assert webhook.save
+      end
+      assert_equal webhook.password, '123456'
+      refute_equal webhook.password_in_db, '123456'
+    end
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload

data/test/unit/foreman_webhooks/webhook_service_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module ForemanWebhooks
+  class WebhookServiceTest < ActiveSupport::TestCase
+    let(:event_name) { 'subnet_created' }
+    let(:payload) { { id: 2 } }
+    let(:payload_json) { payload.to_json }
+    let(:webhook) do
+      FactoryBot.build(:webhook, :with_template, template: '<%= payload({id: @payload[:id]}, with_defaults: false) %>')
+    end
+    let(:webhook_service) do
+      WebhookService.new(
+        webhook: webhook,
+        event_name: event_name,
+        payload: payload_json,
+        headers: {},
+        url: webhook.target_url
+      )
+    end
+
+    it 'executes a request to the configured webhook' do
+      expected = { status: :success, message: '', http_status: 200 }
+
+      stub_request(:post, 'https://hook.example.com/api/callback')
+        .with(
+          body: payload_json,
+          headers: {
+            'Content-Type' => 'application/json'
+          }
+        )
+        .to_return(status: 200, body: '', headers: {})
+
+      assert_equal expected, webhook_service.execute
+    end
+
+    it 'handles a failed request' do
+      expected = { status: :error, message: '', http_status: 404 }
+
+      stub_request(:post, 'https://hook.example.com/api/callback')
+        .with(
+          body: payload_json,
+          headers: {
+            'Content-Type' => 'application/json'
+          }
+        )
+        .to_return(status: 404, body: '', headers: {})
+
+      assert_equal expected, webhook_service.execute
+    end
+  end
+end

data/webpack/ForemanWebhooks/Routes/ForemanWebhooksRoutes.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import WebhooksIndexPage from './Webhooks/WebhooksIndexPage';
+
+const ForemanWebhooksRoutes = [
+  {
+    path: '/webhooks',
+    exact: true,
+    render: props => <WebhooksIndexPage {...props} />,
+  },
+];
+
+export default ForemanWebhooksRoutes;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/EmptyWebhooksTable/index.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import DefaultEmptyState from 'foremanReact/components/common/EmptyState';
+
+const EmptyWebhooksTable = ({ message: { type, text } }) => (
+  <DefaultEmptyState
+    icon={type === 'error' ? 'error-circle-o' : 'add-circle-o'}
+    header={type === 'error' ? __('Error') : __('No Results')}
+    description={text}
+    documentation={null}
+  />
+);
+
+EmptyWebhooksTable.propTypes = {
+  message: PropTypes.shape({
+    type: PropTypes.oneOf(['empty', 'error']),
+    text: PropTypes.string,
+  }),
+};
+
+EmptyWebhooksTable.defaultProps = {
+  message: PropTypes.shape({
+    type: 'empty',
+    text: 'No Results',
+  }),
+};
+
+export default EmptyWebhooksTable;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhookDeleteModal.js

@@ -0,0 +1,43 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+import ForemanModal from 'foremanReact/components/ForemanModal';
+import { foremanUrl } from 'foremanReact/common/helpers';
+
+import { WEBHOOK_DELETE_MODAL_ID } from '../../constants';
+
+const WebhookDeleteModal = ({ toDelete, onSuccess }) => {
+  const { id, name } = toDelete;
+
+  return (
+    <ForemanModal
+      id={WEBHOOK_DELETE_MODAL_ID}
+      title={__('Confirm Webhook Deletion')}
+      enforceFocus
+      submitProps={{
+        url: foremanUrl(`/api/v2/webhooks/${id}`),
+        message: sprintf(__('Webhook %s was successfully deleted'), name),
+        onSuccess,
+        submitBtnProps: {
+          bsStyle: 'danger',
+          btnText: __('Delete'),
+        },
+      }}
+    >
+      {sprintf(__('You are about to delete %s. Are you sure?'), name)}
+      <ForemanModal.Footer />
+    </ForemanModal>
+  );
+};
+
+WebhookDeleteModal.propTypes = {
+  toDelete: PropTypes.object,
+  onSuccess: PropTypes.func.isRequired,
+};
+
+WebhookDeleteModal.defaultProps = {
+  toDelete: {},
+};
+
+export default WebhookDeleteModal;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/EnabledCell.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { CheckIcon, BanIcon } from '@patternfly/react-icons';
+
+const EnabledCell = ({ condition }) =>
+  condition ? <CheckIcon /> : <BanIcon />;
+
+EnabledCell.propTypes = {
+  condition: PropTypes.bool,
+};
+
+EnabledCell.defaultProps = {
+  condition: false,
+};
+
+export default EnabledCell;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/Formatters/__tests__/__snapshots__/enabledCellFormatter.test.js.snap

@@ -0,0 +1,7 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`enabledCellFormatter render 1`] = `
+<EnabledCell
+  condition={true}
+/>
+`;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/Formatters/__tests__/enabledCellFormatter.test.js

@@ -0,0 +1,7 @@
+import { enabledCellFormatter } from '../index';
+
+describe('enabledCellFormatter', () => {
+  it('render', () => {
+    expect(enabledCellFormatter()(true)).toMatchSnapshot();
+  });
+});

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/Formatters/enabledCellFormatter.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import EnabledCell from '../EnabledCell';
+
+const enabledCellFormatter = () => value => <EnabledCell condition={value} />;
+
+export default enabledCellFormatter;

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/Formatters/index.js

@@ -0,0 +1 @@
+export { default as enabledCellFormatter } from './enabledCellFormatter';

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/__tests__/EnabledCell.test.js

@@ -0,0 +1,14 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import EnabledCell from '../EnabledCell';
+
+const fixtures = {
+  'should render blank cell': {
+    condition: false,
+  },
+  'should render marked cell': {
+    condition: true,
+  },
+};
+
+describe('EnabledCell', () =>
+  testComponentSnapshotsWithFixtures(EnabledCell, fixtures));

data/webpack/ForemanWebhooks/Routes/Webhooks/WebhooksIndexPage/Components/WebhooksTable/Components/__tests__/__snapshots__/EnabledCell.test.js.snap

@@ -0,0 +1,17 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`EnabledCell should render blank cell 1`] = `
+<BanIcon
+  color="currentColor"
+  noVerticalAlign={false}
+  size="sm"
+/>
+`;
+
+exports[`EnabledCell should render marked cell 1`] = `
+<CheckIcon
+  color="currentColor"
+  noVerticalAlign={false}
+  size="sm"
+/>
+`;