Description

Currently the vararg workaround eats covariants and specialised.
Consider following:

interface A  {
    fun foo(vararg x: Array<out Any>)
    fun bar(vararg x: IntArray)
    fun <T> oo(vararg ozz: RRR<out T>): Any
}

interface B: A

Actual Behavior

class BMock(...): B  {
    ...
    fun foo(vararg x: Any) {...}
    fun bar(vararg x: Int) {...}
    fun <T> oo(vararg ozz: RRR<*>): Any {...}
   ...
}

Expected Behavior

class BMock(...): B  {
    ...
    fun foo(vararg x: Array<out Any>) {...}
    fun bar(vararg x: IntArray) {...}
    fun <T> oo(vararg ozz: RRR<out T>): Any {...}
   ...
}

Description

If the KMock Plugin is applied directly it causes the following error:
You already registered Kotlin/JS target with another compiler: legacy

Description

Currently kspy is generated always. Even if it is just a minor issue, it would be nice if kspy is not generated at all when not in use.

Description

Currently names, when overloaded and on function/method level, are not correctly resolved for:

• nullable generics
• multi-bounded

Description

Currently KMock generates Members for receivers normal members.

Acceptance Criteria:

• Receiver member proxies are accessable like normal proxies
• receiver members are generated as receivers not as normal members

see here for more.

Description

The current mode of invocation is to error prone and should ideally come with minimum constraints.

Acceptance Criteria

1. The plugin can be applies directly
2. The extension has a handle to provide source precedence while confgured

Description

Once KFixture has been progressed further and is ready to release a much easier support for relaxing will be possible.
However to prepare slowly for a probable plugin a first step should be to provide an entry point for data class dummies.

Acceptance Criteria

1. The extension allows via feature flag to opt-in this behaviour but is disabled by default
2. The extension or via Annotation picks up declared dummies
3. The processor will generate a factory which supports project internal data classes in a limited scope (no generics for now)

Description

Currently BuildIns are resolved by their name. Overloaded variants should be resolved nevertheless even if no BuildIns are set. However this is not the case at the moment.

Description

While Mocks are generated, the Generator fails if the KSP Source Folder is not empty. This effects only Native.

Description

Provide a workaround for google/ksp#958.

Description

Currently the prefixes of type names are filtered instead of allow listed.
This actually can cause unnecessarily boilerplate. The avoidance of collisions can be done when an error occurs by a consumer.

Acceptance Criteria:

1. Add 2 new fields to the Extension - one as a feature flag/switch between the already implemented version and the new to avoid a breaking change. One for the allowList.

2. Deprecated the existing flag.

3. Processor implements the switch as well as the new behaviour for the FunctionGenerator/MethodGenerator

Description

Currently platform factory methods for KMP always use expect/actual and do not respect platform only cases.

Acceptance Critera:

• Factories for generics are using the appropriate modifier according if they implement a meta source or not.

Description

Since the AccessMethods depend on the SideEffect signature, they can be grouped wrongly if TypeAliases are in the mix.
This can cause an additional AccessMethod which collides with a correctly added Method.
Possible Fixes are:
Either use only the abbreviate type or it only when creating the keys for the AccessMethods.

Description

The publishing of the GradlePlugin is slightly wrong configured.

Expected Behavior

<artifactId>kmock-gradle.gradle.plugin</artifactId>

Actual Behavior

<artifactId>tech.antibytes.kmock.kmock-gradle.gradle.plugin</artifactId>

Description

Expected Behavior

Noise does not show up.

Actual Behavior

w: .../kmock-playground/example-js/build/generated/ksp/js/test/kotlin/tech/antibytes/kmock/example/MockFactory.kt: (28, 3): Parameter 'verifier' is never used
w: .../kmock-playground/example-js/build/generated/ksp/js/test/kotlin/tech/antibytes/kmock/example/MockFactory.kt: (29, 3): Parameter 'freeze' is never used
w: .../kmock-playground/example-js/build/generated/ksp/js/test/kotlin/tech/antibytes/kmock/example/MockFactory.kt: (30, 17): The expression is unused

Possible Fix

Simply apply @Suppress("UNUSED_PARAMETER") and @Suppress("UNUSED_EXPRESSION") file wide on factories.

Steps to Reproduce

Run ./gradlew check in the Playground

Description

Currently KMock only supports definitions for shared sources via @MockShared.
While it is good enough for smaller projects it might not for middle sized or bigger once with many different sources. Custom Annotations can help here.

Acceptance Criteria:

• The Extension allows definition of custom Annotations for shared sources.
• The processor picks them up and hooks them in alongside with @MockShared.

Description

Currently Relaxation for Interfaces with generics causes an Compiler Error.
This only applies for inline functions. (The need additional arguments and cannot be inline in this case)

Description

Currently the TestCase Given find it fetches a DomainObjects does not run for native in the integration KMP.

Description

Currently only single interface mocks are allowed, but not the union of n-parents with n>1.
This could be "easily" done by also consuming Arrays via the already existing Annotations or via new Annotations (possibly the better way since it keeps the type system intact).

Description

Things like:

interface X {
    fun <T : Map<String, W>, W : G, G> foo(arg: T) where G : CharSequence?, G : Comparable<T>?
    fun <T : Map<String, W>, W : G, G> bar(vararg arg: T) where G : CharSequence?, G : Comparable<T>?
}

are resolved incorrectly with having the boundaries completely replaced W instead with Any.

Description

Currently shared source can be filtered out in certain cases:

1. n (n>1) Sources contain a interface with the same name under the same package
2. those sources are not dependent on each other
3. those sources have a different precedence

Description

spyOn mostly adds to custom optimisation, but can be error prone and inconvenient. Therefore an additional flag to enableAll the spies might be a good addition to complement the selective approach.

Acceptance Criteria:

• Add to the GradleExtension a flag and propagate the change to the processor which enables for all (applicable) Mocks Spies

Description

Currently vararg is currently not supported, which it should.

Expected Behavior

interface Platform {
    fun bar(vararg buzz: Int)
}

should be:

internal class PlatformMock(
    ..
) : Platform {
   ..

    public val _bar: KMockContract.SyncFunProxy<Unit, (Array<Int>) -> Unit> = 
            
      ..

    public override fun bar(vararg buzz: Int) = _bar.invoke(buzz)

    ..
}

Actual Behavior

internal class PlatformMock(
    ...
) : Platform {
   ..

    public val _bar: KMockContract.SyncFunProxy<Unit, (Int) -> Unit> = 
            
      ..

    public override fun bar(vararg buzz: Int) = _bar.invoke(buzz)

    ..
}

Possible Fix

KSValueParameter has a isVararg property, which needs to be propagated starting from determineParameter.

Description

In my project, we have an extra source-set between common and the platform called mobile(Main/Test)
We use it to avoid exposing mobile-only classes to JS

Expected Behavior

When using @MockShared("mobileTest", MobileMainClass::class), it should generate the mock for the mobileTest source-set

Actual Behavior

The mock class is not being generated

Steps to Reproduce

1. Download example project https://github.com/faogustavo/KMockExample
2. Open the ViewModelTest class
3. Try to run

Your Environment

• Version used: Snapshot

Description

Currently invoke accepts any value, since there is no generic value given.

Description

Given a Relaxer is defined the processor does not picks it if the tests run without changes multiple times.

Description

The current implemented Assertion feel wrong, aesthetically and and from the handling since they combine actual arguments and boundaries.

Consider instead doing:

assert(mock._someProxy) { hasBeenCalled().times(42) }

or

assert { mock._someProxy.hasBeenCalled().times(42) }

or similar.

This could be a better fit. Additionally this should deprecate the current Assertions and verify. Also consider a non breaking renaming of the current methods of the verifiers to fit the overall naming convention and since they currently act like assertions.

Description

Currently MockShared needs the full SourceSet name, while only the prefix (eg. common) is sufficient.

Acceptance Criteria:

• MockShared with only the prefix
• MockShared with the complete name for test sources

Description

The processor currently has (too) many loops. They can be reduced by using an emitter like approach and other micro optimisations.

Description

See here fore more.
This can only fixed if the KSP issue is resolved.

Description

Currently freeze is always true by default, which can harm the dev experience even if it is not needed.
Simple solution is to make it configurable via the Extension of the GradlePlugin.

Acceptance Criteria:

• The GradleExtension has a new field, which is true on default but can be switched to false
• this value gets propagated to the Processor which uses it as default for the factories.

Currently kspy is generated for kspy even if they are not enabled. While using them it will simply fails.

Acceptance criteria:

• do not generate the deceiving factories

Description

Currently instrumented Android Test are not hooked into KMock...but they should

Description

Support alternative on Expectations on argument level for more convenience and readability.

Description

Provide a more robust (experimental) proxy API.

Description

KMock primarily aims on an intrusive approach. While it supports spying, there is no possibility to deactivate the kmock completely. As discussed elsewhere, KMock should also support this kind of approach.

Acceptance criteria:

1. Add a feature flag spyOnly, which is false on default.
2. If this flag is true, the processor should not produce kmock, but enable all captured interfaces for spying.

Currently the Plugin might fail if there is a meta source without concrete platforms. For example there is a darwin sourceset without iOS.

Description

Currently things like:

interface Collision {
  fun <T : Something<K>, K> foo(arg: T)
  fun <T : Something<R>, R> bar(arg: T)
}

cause collisions since the Parameter are not entirely resloved.

Description

Currently nested types are not resolved, which can lead to collisions in JS and Native (but not JVM!!)

Description

Currently the resolved name of generic and non generic methods might clash if the name if is already in use. In order to solve that a additional prefix might be needed to divide them if neccessary.

Description

Currently the Processor hardwires all the Relaxers into the Mocks. At least the UnitRelaxer can be invoked with the ProxyFactory.

Acceptance Criteria:
At least relaxVoidFunction is wired by the ProxyFactory.

Optional:
Find a way to make that for all relaxers and Spies, in order to improve testability.

Description

Currently it is super hard to initialise Multi-Interface Mocks which are based on generic Interface(s), due to their special nature. Practical speaking it renders them useless.
This must be improved! For example using the MockType instead of the TemplateTypes.

Description

As the title states. Since KSP cannot determine which Alias is expect/actual due to the separation of production and test, let's do for now a manual workaround in order to flag Aliases which cause that.
This should be improved with future releases!

Description

The runtime is slower than it has to be.

Acceptance Criteria:

• Move the freezing/non freezing behaviour on ProxyFactory level
• Improve verifyOrder and verifyStrictOrder