foreman_puppet 0.0.1 → 1.0.0.rc.2

data/test/graphql/mutations/hosts/create_mutation_test.rb

@@ -0,0 +1,87 @@
+require 'test_puppet_helper'
+
+module ForemanPuppet
+  module Mutations
+    module Hosts
+      class CreateMutationTest < GraphQLQueryTestCase
+        let(:hostname) { 'my-graphql-host' }
+        let(:tax_location) { FactoryBot.create(:location) }
+        let(:organization) { FactoryBot.create(:organization) }
+        let(:environment) { FactoryBot.create(:environment, locations: [tax_location], organizations: [organization]) }
+        let(:environment_id) { Foreman::GlobalId.for(environment) }
+        let(:puppetclass) { FactoryBot.create(:puppetclass) }
+        let(:puppetclass_id) { Foreman::GlobalId.for(puppetclass) }
+
+        let(:variables) do
+          {
+            name: hostname,
+            environmentId: environment_id,
+            puppetclassIds: [puppetclass_id],
+            interfacesAttributes: [
+              {
+                type: 'bond',
+                attachedTo: %w[eth0 eth1],
+                identifier: 'bond0',
+                primary: true,
+                provision: true,
+                managed: true,
+              },
+            ],
+          }
+        end
+        let(:context_user) { FactoryBot.create(:user, :admin, locations: [tax_location], organizations: [organization]) }
+        let(:data) { result['data']['createHost']['host'] }
+
+        let(:query) do
+          <<-GRAPHQL
+            mutation createHostMutation(
+                $name: String!,
+                $environmentId: ID,
+                $puppetclassIds: [ID!],
+                $interfacesAttributes: [InterfaceAttributesInput!]
+              ) {
+              createHost(input: {
+                name: $name,
+                environmentId: $environmentId,
+                puppetclassIds: $puppetclassIds,
+                interfacesAttributes: $interfacesAttributes,
+              }) {
+                host {
+                  id
+                },
+                errors {
+                  path
+                  message
+                }
+              }
+            }
+          GRAPHQL
+        end
+
+        setup :disable_orchestration
+
+        it 'creates a host with puppet parameters' do
+          assert_difference(-> { Host.count }, +1) do
+            assert_empty result['errors']
+            assert_empty result['data']['createHost']['errors']
+
+            host = Host.find(Foreman::GlobalId.decode(data['id'])[2])
+            assert_equal environment.id, host.puppet.environment_id
+            assert_equal [puppetclass.id], host.puppet.puppetclasses.pluck(:id)
+
+            assert_equal 1, host.interfaces.count
+            interface = host.interfaces.first
+            assert_equal 'Nic::Bond', interface.type
+            assert_equal 'eth0, eth1', interface.attached_to
+            assert_equal 'bond0', interface.identifier
+            assert interface.primary
+            assert interface.provision
+            assert interface.managed
+
+            assert_not_nil data
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql/queries/environment_query_test.rb

@@ -0,0 +1,54 @@
+require 'test_puppet_helper'
+
+module Queries
+  class EnvironmentQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        environment(id: $id) {
+          id
+          createdAt
+          updatedAt
+          name
+          locations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          organizations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:environment) { FactoryBot.create(:environment) }
+
+    let(:global_id) { Foreman::GlobalId.for(environment) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['environment'] }
+
+    test 'fetching environment attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal environment.created_at.utc.iso8601, data['createdAt']
+      assert_equal environment.updated_at.utc.iso8601, data['updatedAt']
+      assert_equal environment.name, data['name']
+
+      assert_collection environment.locations, data['locations']
+      assert_collection environment.organizations, data['organizations']
+    end
+  end
+end

data/test/graphql/queries/environments_query_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Queries
+  class EnvironmentsQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        environments {
+          totalCount
+          pageInfo {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+          edges {
+            cursor
+            node {
+              id
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['environments'] }
+
+    setup do
+      FactoryBot.create_list(:environment, 2)
+    end
+
+    test 'fetching environments attributes' do
+      assert_empty result['errors']
+
+      expected_count = ForemanPuppet::Environment.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['edges'].count
+    end
+  end
+end

data/test/{qraphql → graphql}/queries/host_puppet_query_test.rb

@@ -12,9 +12,6 @@ module Queries
           environment {
             id
           }
-          puppetProxy {
-            id
-          }
         }
       }
       GRAPHQL
@@ -23,14 +20,12 @@ module Queries
     let(:host) { FactoryBot.create(:host, :with_puppet_enc) }
     let(:global_id) { Foreman::GlobalId.encode('Host', host.id) }
     let(:variables) { { id: global_id } }
+    let(:data) { result['data']['host'] }
 
     test 'fetching host attributes' do
-      skip 'GraphQL is TODO'
-      host_data = result['data']['host']
       assert_empty result['errors']
-      assert_equal global_id, host_data['id']
-      assert_record host.environment, host_data['environment']
-      assert_record host.puppet_proxy, host_data['puppetProxy']
+      assert_equal global_id, data['id']
+      assert_record host.environment, data['environment']
     end
   end
 end

data/test/{qraphql → graphql}/queries/hostgroup_puppet_query_test.rb

@@ -12,25 +12,20 @@ module Queries
           environment {
             id
           }
-          puppetProxy {
-            id
-          }
         }
       }
       GRAPHQL
     end
 
-    let(:hostgroup) { FactoryBot.create(:hostgroup, :with_puppet_enc) }
+    let(:hostgroup) { FactoryBot.create(:hostgroup, :with_puppet_enc, :with_puppetclass) }
     let(:global_id) { Foreman::GlobalId.encode('Hostgroup', hostgroup.id) }
     let(:variables) { { id: global_id } }
 
     test 'fetching host attributes' do
-      skip 'GraphQL is TODO'
       hostgroup_data = result['data']['hostgroup']
       assert_empty result['errors']
       assert_equal global_id, hostgroup_data['id']
       assert_record hostgroup.puppet.environment, hostgroup_data['environment']
-      assert_record hostgroup.puppet_proxy, hostgroup_data['puppetProxy']
     end
   end
 end

data/test/graphql/queries/location_query_test.rb

@@ -0,0 +1,52 @@
+require 'test_puppet_helper'
+
+module Queries
+  class LocationQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        location(id: $id) {
+          id
+          environments {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          puppetclasses {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:location_object) { FactoryBot.create(:location, environments: [environment]) }
+
+    let(:global_id) { Foreman::GlobalId.for(location_object) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['location'] }
+
+    setup do
+      FactoryBot.create(:puppetclass, environments: [environment])
+    end
+
+    test 'fetching location attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_collection location_object.environments, data['environments']
+      assert_collection location_object.puppetclasses, data['puppetclasses']
+    end
+  end
+end

data/test/graphql/queries/organization_query_test.rb

@@ -0,0 +1,52 @@
+require 'test_puppet_helper'
+
+module Queries
+  class OrganizationQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        organization(id: $id) {
+          id
+          environments {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          puppetclasses {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:organization_object) { FactoryBot.create(:organization, environments: [environment]) }
+
+    let(:global_id) { Foreman::GlobalId.for(organization_object) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['organization'] }
+
+    setup do
+      FactoryBot.create(:puppetclass, environments: [environment])
+    end
+
+    test 'fetching organization attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_collection organization_object.environments, data['environments']
+      assert_collection organization_object.puppetclasses, data['puppetclasses']
+    end
+  end
+end

data/test/graphql/queries/puppetclass_query_test.rb

@@ -0,0 +1,68 @@
+require 'test_puppet_helper'
+
+module Queries
+  class PuppetclassQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        puppetclass(id: $id) {
+          id
+          createdAt
+          updatedAt
+          name
+          environments {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          locations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+          organizations {
+            totalCount
+            edges {
+              node {
+                id
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:environment) { FactoryBot.create(:environment) }
+    let(:puppetclass) { FactoryBot.create(:puppetclass) }
+
+    let(:global_id) { Foreman::GlobalId.for(puppetclass) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['puppetclass'] }
+
+    setup do
+      FactoryBot.create(:environment_class, puppetclass: puppetclass, environment: environment)
+    end
+
+    test 'fetching puppetclass attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal puppetclass.created_at.utc.iso8601, data['createdAt']
+      assert_equal puppetclass.updated_at.utc.iso8601, data['updatedAt']
+      assert_equal puppetclass.name, data['name']
+
+      assert_collection puppetclass.environments, data['environments']
+      assert_collection puppetclass.locations, data['locations']
+      assert_collection puppetclass.organizations, data['organizations']
+    end
+  end
+end

data/test/graphql/queries/puppetclasses_query_test.rb

@@ -0,0 +1,43 @@
+require 'test_puppet_helper'
+
+module Queries
+  class PuppetclassesQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        puppetclasses {
+          totalCount
+          pageInfo {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+          edges {
+            cursor
+            node {
+              id
+            }
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['puppetclasses'] }
+
+    setup do
+      FactoryBot.create_list(:puppetclass, 2)
+    end
+
+    test 'fetching puppetclasses attributes' do
+      assert_empty result['errors']
+
+      expected_count = ForemanPuppet::Puppetclass.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['edges'].count
+    end
+  end
+end