Maintenance fixes (absinthe-graphql#1016)

* Rename test file so its executed by the test runner

* Fix unused returned values

* Remove unused files

* Remove unused requires

* Add assertions checking import_types options

* Add import_types/2 to locals_without_parens

* Add documentation for :only/:except on import_types

* Fix formatting

Co-authored-by: Vince Foley <39946+binaryseed@users.noreply.github.com>

.formatter.exs

@@ -18,6 +18,7 @@ locals_without_parens = [
   import_fields: 2,
   import_fields: 1,
   import_types: 1,
+  import_types: 2,
   import_sdl: 1,
   import_sdl: 2,
   input_object: 3,

lib/absinthe/language/document.ex

@@ -1,8 +1,6 @@
 defmodule Absinthe.Language.Document do
   @moduledoc false
 
-  require Logger
-
   alias Absinthe.{Blueprint, Language}
 
   defstruct definitions: [],

lib/absinthe/pipeline.ex

@@ -8,8 +8,6 @@ defmodule Absinthe.Pipeline do
 
   alias Absinthe.Phase
 
-  require Logger
-
   @type data_t :: any
 
   @type phase_config_t :: Phase.t() | {Phase.t(), Keyword.t()}

lib/absinthe/schema/notation.ex

@@ -1231,7 +1231,9 @@ defmodule Absinthe.Schema.Notation do
 
   Very frequently your schema module will simply have the `query` and `mutation`
   blocks, and you'll want to break out your other types into other modules. This
-  macro imports those types for use the current module
+  macro imports those types for use the current module.
+
+  To selectively import types you can use the `:only` and `:except` opts.
 
   ## Placement
 
@@ -1242,6 +1244,10 @@ defmodule Absinthe.Schema.Notation do
   import_types MyApp.Schema.Types
 
   import_types MyApp.Schema.Types.{TypesA, TypesB}
+
+  import_types MyApp.Schema.Types, only: [:foo]
+
+  import_types MyApp.Schema.Types, except: [:bar]
   ```
   """
   defmacro import_types(type_module_ast, opts \\ []) do

lib/absinthe/subscription.ex

@@ -28,7 +28,6 @@ defmodule Absinthe.Subscription do
   - More user control over back pressure / async balance.
   """
 
-  require Logger
   alias __MODULE__
 
   @doc """

lib/mix/tasks/absinthe.schema.sdl.ex

@@ -1,5 +1,4 @@
 defmodule Mix.Tasks.Absinthe.Schema.Sdl do
-  require Logger
   use Mix.Task
   import Mix.Generator
 

mix.exs

@@ -179,8 +179,7 @@ defmodule Absinthe.Mixfile do
         Absinthe.Pipeline,
         Absinthe.Phase,
         Absinthe.Phase.Document.Context,
-        Absinthe.Phase.Telemetry,
-        Absinthe.Pipeline.ErrorResult
+        Absinthe.Phase.Telemetry
       ],
       "Document Adapters": [
         Absinthe.Adapter,

test/absinthe/schema/manipulation_test.exs

@@ -1,6 +1,5 @@
 defmodule Absinthe.Schema.ManipulationTest do
   use Absinthe.Case, async: true
-  require IEx
 
   alias Absinthe.Phase.Schema.Validation.TypeNamesAreReserved
 

test/absinthe/schema/notation/experimental/import_types_test.exs

@@ -17,34 +17,55 @@ defmodule Absinthe.Schema.Notation.Experimental.ImportTypesTest do
   end
 
   defmodule WithoutOptions do
-    use Absinthe.Schema.Notation
+    use Absinthe.Schema
+
+    query do
+    end
 
     import_types Source
   end
 
   defmodule UsingOnlyOption do
-    use Absinthe.Schema.Notation
+    use Absinthe.Schema
+
+    query do
+    end
 
     import_types(Source, only: [:one, :two])
   end
 
   defmodule UsingExceptOption do
-    use Absinthe.Schema.Notation
+    use Absinthe.Schema
+
+    query do
+    end
 
     import_types(Source, except: [:one, :two])
   end
 
   describe "import_types" do
     test "without options" do
       assert [{Source, []}] == imports(WithoutOptions)
+
+      assert WithoutOptions.__absinthe_type__(:one)
+      assert WithoutOptions.__absinthe_type__(:two)
+      assert WithoutOptions.__absinthe_type__(:three)
     end
 
     test "with :only" do
       assert [{Source, only: [:one, :two]}] == imports(UsingOnlyOption)
+
+      assert UsingOnlyOption.__absinthe_type__(:one)
+      assert UsingOnlyOption.__absinthe_type__(:two)
+      refute UsingOnlyOption.__absinthe_type__(:three)
     end
 
     test "with :except" do
       assert [{Source, except: [:one, :two]}] == imports(UsingExceptOption)
+
+      refute UsingExceptOption.__absinthe_type__(:one)
+      refute UsingExceptOption.__absinthe_type__(:two)
+      assert UsingExceptOption.__absinthe_type__(:three)
     end
   end
 

test/support/case/assertions/schema.ex

@@ -20,16 +20,17 @@ defmodule Absinthe.Case.Assertions.Schema do
         load_schema(schema_name)
       end
 
-    patterns
-    |> Enum.filter(fn pattern ->
-      assert Enum.find(err.phase_errors, fn error ->
-               keys = Map.keys(pattern)
-               Map.take(error, keys) |> handle_path == pattern |> handle_path
-             end),
-             "Could not find error detail pattern #{inspect(pattern)}\n\nin\n\n#{
-               inspect(err.phase_errors)
-             }"
-    end)
+    patterns =
+      patterns
+      |> Enum.filter(fn pattern ->
+        assert Enum.find(err.phase_errors, fn error ->
+                 keys = Map.keys(pattern)
+                 Map.take(error, keys) |> handle_path == pattern |> handle_path
+               end),
+               "Could not find error detail pattern #{inspect(pattern)}\n\nin\n\n#{
+                 inspect(err.phase_errors)
+               }"
+      end)
 
     assert length(patterns) == length(err.phase_errors)
   end