content: module Unused.ParserSpec where
  
  import qualified Data.Map.Strict as Map
  import Test.Hspec
  import Unused.Parser
  import Unused.ResultsClassifier
  import Unused.TermSearch
  import Unused.Types
  
  main :: IO ()
  main = hspec spec
  
  spec :: Spec
  spec =
      parallel $
      describe "parseResults" $ do
          it "parses from the correct format" $ do
              let r1Matches =
                      [ TermMatch "method_name" "app/path/foo.rb" Nothing 1
                      , TermMatch "method_name" "app/path/other.rb" Nothing 5
                      , TermMatch "method_name" "spec/path/foo_spec.rb" Nothing 10
                      ]
              let r1Results =
                      TermResults
                          "method_name"
                          ["method_name"]
                          r1Matches
                          (Occurrences 1 10)
                          (Occurrences 2 6)
                          (Occurrences 3 16)
                          (Removal Low "used frequently")
                          Nothing
              let r2Matches = [TermMatch "other" "app/path/other.rb" Nothing 1]
              let r2Results =
                      TermResults
                          "other"
                          ["other"]
                          r2Matches
                          (Occurrences 0 0)
                          (Occurrences 1 1)
                          (Occurrences 1 1)
                          (Removal High "occurs once")
                          Nothing
              let (Right config) = loadConfig
              let result = parseResults config $ SearchResults $ r1Matches ++ r2Matches
              result `shouldBe` Map.fromList [("method_name", r1Results), ("other", r2Results)]
          it "parses when no config is provided" $ do
              let r1Matches =
                      [ TermMatch "method_name" "app/path/foo.rb" Nothing 1
                      , TermMatch "method_name" "app/path/other.rb" Nothing 5
                      , TermMatch "method_name" "spec/path/foo_spec.rb" Nothing 10
                      ]
              let r1Results =
                      TermResults
                          "method_name"
                          ["method_name"]
                          r1Matches
                          (Occurrences 1 10)
                          (Occurrences 2 6)
                          (Occurrences 3 16)
                          (Removal Low "used frequently")
                          Nothing
              let result = parseResults [] $ SearchResults r1Matches
              result `shouldBe` Map.fromList [("method_name", r1Results)]
          it "handles aliases correctly" $ do
              let r1Matches = [TermMatch "admin?" "app/path/user.rb" Nothing 3]
              let r2Matches =
                      [ TermMatch "admin?" "spec/models/user_spec.rb" (Just "be_admin") 2
                      , TermMatch
                            "admin?"
                            "spec/features/user_promoted_to_admin_spec.rb"
                            (Just "be_admin")
                            2
                      ]
              let (Right config) = loadConfig
              let searchResults = r1Matches ++ r2Matches
              let result = parseResults config $ SearchResults searchResults
              let results =
                      TermResults
                          "admin?"
                          ["admin?", "be_admin"]
                          searchResults
                          (Occurrences 2 4)
                          (Occurrences 1 3)
                          (Occurrences 3 7)
                          (Removal Low "used frequently")
                          Nothing
              result `shouldBe` Map.fromList [("admin?|be_admin", results)]
          it "handles empty input" $ do
              let (Right config) = loadConfig
              let result = parseResults config $ SearchResults []
              result `shouldBe` Map.fromList []
  