Unit Testing a Static Method of a Static Class

One should try to avoid coupling code to static classes as they are difficult to test.

That said, with your current code as is, it can be refactored to allow certain separations of concerns and a more fluent API via extension methods.

public static class ApplicationUtils {
    public static Func<IIdentity> userFactory = () => WindowsIdentity.GetCurrent();

    public static IIdentity CurrentUser { get { return userFactory(); } }

    public static bool IsManager(this IIdentity identity) {
        return identity != null && string.Compare(identity.Name, "AdminUser", true) == 0;
    }

    public static bool IsAuthenticated(this IIdentity identity) {
        return identity != null && identity.IsAuthenticated;
    }
}

The following test is used as an example to demonstrate how the above is used.

Moq was used as mocking framework

[TestMethod]
public void IsManager_Should_Return_True_For_AdminUser() {
    //Arrange
    var name = "AdminUser";
    var identity = Mock.Of<IIdentity>(_ => _.Name == name);
    ApplicationUtils.userFactory = () => identity;

    //Act
    var actual = ApplicationUtils.CurrentUser.IsManager();

    //Assert
    Assert.IsTrue(actual);
}

That done I would now like to suggest you refactor your code to make it more SOLID.

Abstract the functionality of getting the current user out into a service provider.

public interface IIdentityProvider {
    IIdentity CurrentUser { get; }
}

Pretty simple with an even simpler implementation.

public class DefaultIdentityProvider : IIdentityProvider {
    public IIdentity CurrentUser {
        get { return WindowsIdentity.GetCurrent(); }
    }
}

If using DI you can now inject the provider into dependent classes that have need to access the current user.

This allows the code to more flexible and maintainable as mocks/stubs of the provider and user can be used for isolated unit tests. The extension methods remain the same as they have very simple concerns.

Here is a simple example of a test for the extension method from earlier.

[TestMethod]
public void IsManager_Should_Return_True_For_AdminUser() {
    //Arrange
    var name = "AdminUser";
    var identity = Mock.Of<IIdentity>(_ => _.Name == name);
    var provider = Mock.Of<IIdentityProvider>(_ => _.CurrentUser == identity);

    //Act
    var actual = provider.CurrentUser.IsManager();

    //Assert
    Assert.IsTrue(actual);
}

Purely for demonstrative purposes, the test for the IsManager extension method only really needs an IIdentity to be exercised.

Assert.IsTrue(Mock.Of<IIdentity>(_ => _.Name == "AdminUser").IsManager());

When your code is difficult to test, changing the code is a viable option! In this case, consider having the IsCurrentUserAManager receive the username as an input parameter (and rename it to IsUserAManager to reflect the change in behavior). It would look something like this:

public static class ApplicationUtils
{
   public static bool IsUserAManager(string username)
   {
      bool inAdmin;

      if (username == "AdminUser") {
         inAdmin = true;
      } else {
         inAdmin = false;
      }

      return inAdmin;
   }
}

This will allow you to send in different values for testing different scenarios. If however the entire class as it is cannot appear in the UT (due to environment constraints on initialization, for example), consider having just the business logic exported to a seperate non static class and write your UT for that.

public static class ApplicationUtils
    {
        // this is not testable, because I dont use DI
        public static bool IsCurrentUserAManager() => TestableMethod(WindowsIdentity.GetCurrent().Name);

        // This is testable because it contains logics (if-else)
        public static bool TestableMethod(string username) => username == "AdminUser";
    }

    [TestMethod]
    public void IsCurrentUserAManagerTestIsAdmin()
    {
        Assert.IsTrue(ApplicationUtils.TestableMethod("AdminUser"));
        Assert.IsFalse(ApplicationUtils.TestableMethod("adminuser"));
    }